[Demo] Bat dau lam quen voi Raspberry Pi

ungdungmaytinh.com
MỤC LỤC
Lời nói đầu..............................................................................................................7
Raspberry Pi Foundation.................................................................................7
Bạn có thể làm gì với nó? .................................................................................7
Raspberry Pi cho Markers...............................................................................8
Linux và Raspberry Pi ....................................................................................10
Quy ước dùng trong sách...............................................................................10
Chương 1 Bắt đầu và Điều khiển......................................................................13
Giới thiệu chung về Raspberry Pi ................................................................13
Các thiết bị Ngoại vi Thích hợp.....................................................................18
Hộp đựng (Case)..............................................................................................21
Chọn Phiên bản Hệ Điều hành ......................................................................23
Flash thẻ SD ......................................................................................................23
Khởi động..........................................................................................................24
Định cấu hình Pi...............................................................................................25
Online ................................................................................................................27
Tắt Pi..................................................................................................................29
Troubleshooting (Khắc phục Sự cố)............................................................30
Chương 2 Linux trên Raspberry Pi..................................................................31
Sử dụng Command Line .................................................................................34
Các lệnh Linux khác ........................................................................................39
/etc .....................................................................................................................45
Đặt ngày và giờ.................................................................................................46
Cài đặt Phần mềm mới ...................................................................................46
Âm thanh trong Linux.....................................................................................47
Nâng cấp Firmware.........................................................................................48
Chương 3 Hệ Điều hành khác và Các bản Distribution Linux ....................49

Bản distribution cho Giải trí tại nhà........................................................... 50
Bản distribution cho Âm nhạc...................................................................... 51
Retrocomputing và Retrogaming................................................................ 51
Internet of Things........................................................................................... 52
Các bản distribution hữu ích khác .............................................................. 53
Chương 4 Python trên Pi................................................................................... 55
Hello, Python ................................................................................................... 56
Thêm một chút về Python............................................................................. 58
Đối tượng và Mô-đun..................................................................................... 60
Những mô-đun khác....................................................................................... 63
Khởi chạy các Chương trình khác từ Python............................................ 66
Khắc phục Sự cố .............................................................................................. 67
Chương 5 Arduino và Pi .................................................................................... 69
Cài đặt Arduino trong Raspbian .................................................................. 70
Giao tiếp bằng Serial ...................................................................................... 72
Sử dụng Firmata ............................................................................................. 76
Chương 6 Input và Output Cơ bản................................................................... 77
Sử dụng Input và Output ............................................................................... 79
Dự án: Cron Lamp Timer............................................................................... 88
Chương 7 Lập trình Input và Output bằng Python ...................................... 93
Kiểm tra GPIO bằng Python.......................................................................... 93
Nhấp nháy LED ................................................................................................ 95
Đọc một Nút ..................................................................................................... 97
Dự án: Soundboard đơn giản ....................................................................... 99
Chương 8 Input và Output Analog................................................................. 105
Output: Chuyển đổi Digital thành Analog................................................ 106
Input: Chuyển đổi Analog sang Digital ..................................................... 109
Chương 9 Làm việc với Camera..................................................................... 119
Kết nối và Kiểm tra Mô-đun Camera......................................................... 121

ungdungmaytinh.com
Cài đặt và Thử nghiệm SimpleCV ...............................................................125
Hiển thị Hình ảnh ..........................................................................................127
Sửa một hình ảnh ..........................................................................................128
Truy cập Camera ...........................................................................................130
Phát hiện Khuôn mặt....................................................................................132
Dự án: Raspberry Pi Photobooth ...............................................................133
Chương 10 Python và Internet.......................................................................139
Tải Dữ liệu từ Máy chủ web.........................................................................139
Máy chủ Pi (Làm Web Server).....................................................................146
Kết nối Web với Thế giới Thật....................................................................150
Dự án: WebLamp...........................................................................................152

ungdungmaytinh.com
Chương 4
Python trên Pi
Python là một ngôn ngữ lập trình tuyệt vời, rõ ràng và dễ dàng để bắt đầu
và chạy. Quan trọng hơn, có rất nhiều người dùng quan tâm.
Guido van Rossum đã tạo ra Python rất sớm và sử dụng nó như một ngôn
ngữ đầu tiên cho máy tính. Năm 1999, van Rossum đã đưa ra một đề xuất
được gọi rộng rãi là “Computer Programming for Everybody”, đưa ra một
tầm nhìn cho một chương trình đầy tham vọng để dạy lập trình sử dụng
Python ở các trường tiểu học và trung học. Hơn một thập kỷ sau, điều đó
được tiến hành với sự xuất hiện của Raspberry Pi.
Python là một ngôn ngữ thông dịch, có nghĩa là có thể viết một chương trình
hoặc script và thực thi nó trực tiếp thay vì biên dịch nó thành mã máy. Các
ngôn ngữ thông dịch được lập trình nhanh hơn chút ít, và bạn có được thêm
chút lợi thế phụ. Ví dụ: bằng Python, không phải nói rõ cho máy tính hiểu
một biến có phải là số, danh sách hay chuỗi không; trình thông dịch sẽ tự
suy ra kiểu dữ liệu khi thực thi đoạn mã (script).
Trình thông dịch Python có thể được chạy theo hai cách: là một shell tương
tác để thực thi các câu lệnh riêng lẻ, hoặc như một chương trình command-
line để thực thi các script độc lập. Môi trường phát triển tích hợp (IDE) đi
kèm với Python và Raspberry Pi được gọi là IDLE.
Khúc mắc về Phiên bản Python
Lý do có hai phiên bản IDLE là có hai phiên bản Python được cài đặt trên
Pi. Đây là thực tế phổ biến (mặc dù có một chút khó hiểu). Vào lúc quyển
sách này được soạn, Python 3 là mới nhất, nhưng thay đổi được thực hiện
cho ngôn ngữ giữa các phiên bản 2 và 3 làm cho các phiên bản sau này không
tương thích ngược. Dù Python 3 đã tồn tại trong nhiều năm nhưng phải mất
thời gian để nó được chấp nhận rộng rãi, và rất nhiều gói do người dùng
TRUNG TÂM ADVANCECAD
cachdung.com - ungdungmaytinh.com 57

đóng góp chưa được nâng cấp lên Python 3. Nó thậm chí còn khó hiểu hơn
khi tìm kiếm tài liệu Python; hãy chắc rằng bạn tìm kiếm đúng phiên bản!
Phiên bản Python mặc định trên Pi là 2,7. Có thể chạy một Python 3 với:
python3
Các ví dụ trong cuốn sách này sẽ hoạt động với Python 2.7 hoặc 3.X, trừ khi
có ghi chú khác.
Hello, Python
Cách tốt nhất để bắt đầu học Python là bắt đầu ngay lập tức. Mặc dù có thể
sử dụng bất kỳ trình soạn thảo văn bản nào để bắt đầu lập trình, trong cuốn
sách này sẽ bắt đầu sử dụng IDE. Mở ứng dụng IDLE 3. Để chạy IDLE, nhấp
vào menu trên màn hình ở phía dưới bên trái và chọn Programming →
Python (IDLE 3).
Khi IDLE mở ra, một cửa sổ có shell tương tác sẽ xuất hiện. Ba dấu chevron
(>>>) là dấu nhắc tương tác; khi thấy dấu nhắc, điều đó có nghĩa là trình
thông dịch đang đợi câu lệnh của bạn. Ngay tại dấu nhắc, hãy gõ:
>>> print("Saluton Mondo!")
Nhấn Enter hoặc Return. Python thực hiện câu lệnh đó và cho kết quả trong
cửa sổ shell. Bạn có thể sử dụng shell như một loại máy tính để kiểm tra các
câu lệnh hoặc tính toán:
>>> 3+4+5
12
Hãy nghĩ về các câu lệnh thực thi trong shell tương tác như một chương
trình chạy từng dòng lệnh một. Có thể thiết lập biến hoặc nhập module:
>>> import math
>>> (1 + math.sqrt(5)) / 2
1.618033988749895
Lệnh import kích hoạt tất cả các chức năng toán học của Python có sẵn cho
chương trình (tìm hiểu thêm về các mô-đun trong “Đối tượng và Mô-đun”
ở phần sau của chương này). Để thiết lập một biến, sử dụng toán tử gán (=):
>>> import math
>>> radius = 20
>>> radius * 2 * math.pi
58 cachdung.com - ungdungmaytinh.com

ungdungmaytinh.com
1256.6370614359173
Nếu muốn xóa tất cả các biến và bắt đầu ở trạng thái mới, chọn Shell →
Restart Shell để bắt đầu lại. Cũng có thể sử dụng shell tương tác để nhận
thông tin về cách sử dụng một lệnh, mô-đun cụ thể hoặc các chủ đề Python
khác với lệnh help():
help("print")
Để có danh sách tất cả các chủ đề có sẵn, hãy thử:
help("topics")
help("keywords")
help("modules")
Trình thông dịch Python rất tốt cho các lệnh kiểm thử hoặc các phép toán
đơn giản, nhưng thường thì bạn muốn chạy script Python như một ứng
dụng độc lập hơn. Để bắt đầu một chương trình Python mới, chọn File →
New Window, và IDLE sẽ xuất hiện một cửa sổ soạn thảo chương trình (xem
Hình 4-1).
Hãy thử gõ một dòng code và chọn Run → Run Module. Sẽ nhận được cảnh
báo rằng "Source Must Be Saved OK To Save?". Lưu script trong thư mục
chính với tên SalutonMondo.py và nó sẽ được thực hiện trong shell tương tác.
Hình 4-1. Trình tương tác IDLE (bên trái) và cửa sổ editor (bên phải)
Nếu không muốn sử dụng môi trường IDLE, để chạy một chương trình từ
dòng lệnh, hãy mở Terminal và gõ:
python SalutonMondo.py

Thêm một chút về Python
Nếu chuyển sang Python từ môi trường Arduino thì có lẽ bạn đã quen với
việc viết các chương trình (được gọi là sketch trong Arduino, nhưng thường
được gọi là script trong Python) theo định dạng thiết lập/vòng lặp, trong đó
setup() là một hàm chạy một lần và loop() là một hàm thực thi lặp đi lặp
lại. Ví dụ sau đây cho thấy làm thế nào để làm điều này trong Python. Chọn
New Window từ shell tương tác trong IDLE 3 và nhập như sau:
# Setup
n = 0
# Loop
while True:
n = n + 1
# The % is the modulo operator
if ((n % 2) == 0):
print(n)
Chọn Run Module và đặt tên cho script (chẳng hạn như CountEvens.py).
Khi nó chạy, tất cả các số nguyên được in (nhấn Ctrl-C để ngưng output, bởi
vì nó sẽ chạy mãi mãi).
Cũng có thể thực hiện điều này bằng cách sử dụng vòng lặp for mà chỉ đếm
100 số nguyên đầu tiên:
for n in range(0, 100):
if ((n % 2) == 0):
print(n)

Trong ví dụ trên, mỗi hàm con thụt lề là bốn khoảng trắng, không
phải là một tab (nhưng có thể nhấn Tab trong IDLE và nó sẽ chèn
thêm khoảng trắng). Thụt lề có ý nghĩa cấu trúc trong Python. Đây
là một trong những trở ngại lớn cho người mới bắt đầu, hoặc khi
sao chép và dán mã. Tuy nhiên, việc sử dụng khoảng trắng bắt
buộc làm cho Python trở thành một ngôn ngữ khá dễ đọc. Xem
Nguyên tắc về Trình bày Python để biết các mẹo viết code.
Python là một ngôn ngữ có tính cấu trúc cao, sử dụng khoảng trắng để xác
định cấu trúc. Trong ví dụ tiếp theo, các hàm con sẽ được thụt vào một mức
dưới hàm loop() và được coi là một phần của hàm đó. Sự kết thúc của một
vòng lặp được xác định bởi vị trí thụt lề (hoặc cuối file). Điều này khác với

ungdungmaytinh.com
các ngôn ngữ như C phân biệt các hàm trong code bằng dấu ngoặc hoặc các
cách đánh dấu khác.
Sử dụng hàm để đặt đoạn code vào một đoạn code có thể được gọi từ các vị
trí khác trong script. Để viết lại ví dụ trước với các hàm, hãy làm như sau
(khi chạy nó, lưu nó dưới dạng CountEvens.py):
# Declare global variables
n = 0 
# Setup function
def setup(): 
global n
n = 100
def loop(): 
global n
n = n + 1
if ((n % 2) == 0):
print(n)
# Main 
setup()
while True:
loop()
Trong ví dụ này, output sẽ là các số chẵn từ 102 trở đi. Đây là cách nó hoạt
động:
 Đầu tiên, biến n được định nghĩa là một biến chính có thể được sử
dụng trong bất kỳ đoạn code nào trong chương trình lệnh.
 Ở đây, hàm setup() được định nghĩa (nhưng chưa được chạy).
 Tương tự, đây là định nghĩa của hàm loop().
 Trong code chính, setup() được gọi một lần, sau đó đến loop().
Việc sử dụng từ khóa global trong dòng đầu tiên của mỗi hàm là quan
trọng; nó báo cho trình thông dịch sử dụng biến toàn cục n thay vì tạo một
biến thứ hai (cục bộ, hoặc riêng cho hàm đó) n chỉ có thể sử dụng trong hàm.
Hướng dẫn này quá ngắn để trở thành một tài liệu tham khảo Python hoàn
chỉnh. Để thực sự tìm hiểu ngôn ngữ, có thể bắt đầu với Learn Python the
Hard Way, Think Python, hoặc Python Pocket Reference. Phần còn lại của

chương này sẽ cung cấp dây đủ ngữ cảnh để lập trình và chạy với các ví dụ
và chỉ ra các tính năng cơ bản và các mô-đun có sẵn.
Command-line với IDLE
Output của IDLE rất chậm khi chạy code ví dụ để xuất ra shell tương tác.
Để biết nó chậm như thế nào, hãy giữ IDLE mở và mở một cửa sổ mới bên
cạnh. Trong IDLE, chạy script CountEvens bằng cách sử dụng Run Module;
nó sẽ khởi đầu. Sau đó gõ lệnh sau tại dấu nhắc dòng lệnh của terminal:
python CountEvens.py
Khá khó khăn từ việc sử dụng IDE trên các thiết bị khá hạn chế của Pi. Các
ví dụ sau trong cuốn sách sẽ được thực hiện từ command line, nhưng IDLE
vẫn có thể được sử dụng như một trình soạn thảo.
Đối tượng và Mô-đun
Có thể hiểu cú pháp cơ bản của việc xử lý các đối tượng (object) và các mô-
đun thông qua các ví dụ trong cuốn sách này. Python là một ngôn ngữ rõ
ràng, chỉ với 34 keywords dành riêng (xem Bảng 4-1). Những từ khóa này là
phần cốt lõi của ngôn ngữ cho phép tạo cấu trúc và kiểm soát hoạt động
trong script. Khá nhiều thứ không phải là một keywords có thể được coi là
một object. Object là kết hợp dữ liệu và hành vi được đặt tên tên. Có thể thay
đổi dữ liệu của một object, lấy thông tin từ nó, và thậm chí thao tác với các
object khác.
Bảng 4-1. Python chỉ có 34 từ khóa dành riêng
Điều kiện Loop Chức năng tích
hợp sẵn
Hàm, Classes,
Module
Xử lý lỗi
if for print class try
else in pass def def
elif while del global finally
not break break raise
or as nonlocal assert
and continue yield with
is import

ungdungmaytinh.com
True return
False from
None
Trong Python, chuỗi, danh sách, hàm, mô-đun và thậm chí số là các object.
Một object Python có thể được coi như một tập hợp các thuộc tính
(attribtute) và phương pháp (method). Có quyền truy cập vào các attribtute
và method này bằng cách sử dụng cú pháp dấu chấm đơn giản. Ví dụ, gõ
lệnh này tại dấu nhắc shell tương tác để thiết lập một object chuỗi và gọi
method cho phép nó viết hoa chính nó:
>>> myString = "quux"
>>> myString.capitalize()
'Quux'
Hoặc dùng reverse() để sắp xếp lại một danh sách theo thứ tự ngược lại:
>>> myList = ['a', 'man', 'a', 'plan', 'a', 'canal']
>>> myList.reverse()
>>> print(myList)
['canal', 'a', 'plan', 'a', 'man', 'a']

Cả chuỗi và danh sách đều được xây dựng trong các mô-đun của
thư viện chuẩn, có sẵn từ bất kỳ chương trình Python nào. Trong
mỗi trường hợp, chuỗi và danh sách mô-đun đã xác định một loạt
các chức năng để xử lý các chuỗi và danh sách, bao gồm
capitalize() và reverse().
Một số mô-đun thư viện chuẩn không được tích hợp sẵn và cần phải nói rõ
rằng sẽ sử dụng chúng với lệnh import. Để sử dụng mô đun time từ thư
viện chuẩn để truy cập vào các hàm hữu ích để định thời và đấu dóng thời
gian, hãy sử dụng:
import time
Cũng có thể import as để đổi tên mô-đun trong chương trình:
import time as myTime
Hoặc from import để nạp các chức năng lựa chọn từ một mô-đun:
from time import clock

Dưới đây là một ví dụ ngắn về một script Python sử dụng các mô-đun time
và datetime từ thư viện chuẩn để xuất thời gian hiện tại một lần mỗi giây:
from datetime import datetime
from time import sleep
while True:
now = str(datetime.now())
print(now)
sleep(1)
Hàm sleep dừng việc thực hiện chương trình trong một giây. Điều sẽ nhận
thấy sau khi chạy code này là thời gian sẽ chênh lệch một chút mỗi giây.
Đó là vì hai lý do:
• Code không xét đến thời lượng cần để tính toán thời gian hiện tại.
• Các process khác đang chia sẻ CPU và có thể chiếm một vài chu kỳ
tính toán để thực hiện chương trình. Đây là điều quan trọng cần nhớ:
khi lập trình trên Raspberry Pi, không thực hiện trên môi trường thời
gian thực.
Nếu đang sử dụng hàm sleep(), bạn sẽ thấy độ chính xác (nói cách khác là
sai số) đến hơn 5ms trên Pi.
Tiếp theo, hãy sửa ví dụ để mở một file văn bản và ghi lại một số dữ liệu
vào nó một cách định kỳ. Mọi thứ đều là chuỗi khi xử lý các file văn bản. Sử
dụng hàm str() để chuyển đổi các số thành chuỗi (và int() để thay đổi về
một số nguyên):
import random
log = open("log.txt", "w")
for i in range(5):
now = str(datetime.now())
# Generate some random data in the range 0-1024
data = random.randint(0, 1024)
log.write(now + " " + str(data) + "n")
print(".")
sleep(.9)
log.flush()
log.close()

ungdungmaytinh.com

Trong một ứng dụng ghi dữ liệu thực, cần có ngày và giờ chính xác
được thiết lập trên Raspberry Pi, như được mô tả trong phần "Cài
đặt Ngày và Giờ" ở Chương 2.
Đây là một ví dụ khác (ReadFile.py) mà đọc trong một tên file như một đối
số từ command line (chạy nó từ shell với python3 ReadFile.py filename).
Chương trình mở file, đọc từng dòng dưới dạng một chuỗi và in nó. Lưu ý
rằng print() hoạt động giống như println() trong các ngôn ngữ khác, nó
thêm một dòng mới vào chuỗi được in. Đối số end với print() ngăn chặn
dòng mới:
# Open and read a file from command-line argument
import sys
if (len(sys.argv) != 2):
print("Usage: python ReadFile.py filename")
sys.exit()
scriptname = sys.argv[0]
filename = sys.argv[1]
file = open(filename, "r")
lines = file.readlines()
file.close()
for line in lines:
print(line, end = '')
Những mô-đun khác
Một trong những lý do Python rất phổ biến là có một số lượng lớn các mô-
đun do người dùng đóng góp xây dựng trên thư viện chuẩn. Python
Package Index (PyPI) là danh sách các gói (package) (hoặc các mô-đun)
chính thức; một số mô-đun phổ biến hơn đặc biệt hữu ích trên Raspberry Pi
được hiển thị trong Bảng 4-2. Bạn sẽ dùng một số mô-đun này sau, nhất là
mô-đun GPIO để truy cập vào các input và output đa chức năng của
Raspberry Pi.

Bảng 4-2. Một số trình bày quan tâm đặc biệt đối với người dùng Pi
Module Mô tả URL Tên Package
RPi.GPIO
Truy cập các chân
GPIO
sourceforge.net/projects/raspberry-
gpio-python
python-
rpi.gpio
Pygame Gaming framework pygame.org
python-
pygame
SimpleCV
API đơn giản cho
Computer Vision
simplecv.org No package
Scipy Tính toán Khoa học www.scipy.org python-scipy
Numpy
Nền tảng số của
Scipy
numpy.scipy.org python-numpy
Flask
Microframework để
phát triển web
flask.pocoo.org python-flask
Feedparser
Atom và bộ phân
tích RSS feed
pypi.python.org/pypi/feedparser No package
Requests
“HTTP for
Humans”
docs.python-requests.org
python-
requests
PIL Xử lý hình ảnh www.pythonware.com/products/pil/
python-
imaging
wxPython GUI framework wxpython.org
python-
wxgtk2.8
PySerial
Truy cập vào các
ngõ serial
pyserial.sourceforge.net python-serial
pyUSB Giao diện FTDI-USB bleyer.org/pyusb No package
Để sử dụng một trong số các trình bày trên, cần tải code về, định cấu hình
và cài đặt nó. Mô-đun NumPy, ví dụ, có thể được cài đặt như sau:
sudo apt-get install python-numpy

ungdungmaytinh.com
Nếu một package đã được đóng gói bởi người tạo ra nó bằng cách sử dụng
phương pháp chuẩn để đóng gói các mô-đun (với công cụ distutils của
Python), tất cả những gì cần làm là tải file, giải nén nó và gõ:
python setup.py install
Dễ dàng Cài đặt mô-đun với Pip
Nhiều module có thể được cài đặt với apt-get. Cũng có thể xem xét Pip
package installer, một công cụ giúp việc cài đặt các file từ PyPI trở nên dễ
dàng. Cài đặt Pip bằng apt-get:
sudo apt-get install python-pip
Sau đó, có thể cài đặt hầu hết các mô-đun bằng cách sử dụng Pip để quản lý
file tải về và phần phụ thuộc. Ví dụ:
pip install flask
Trong các chương sau, bạn sử dụng các mô-đun cụ thể cho ứng dụng một
cách rộng rãi, nhưng đây là một ví dụ cho thấy mức độ mạnh mẽ của một
số mô-đun. Mô-đun Feedparser là một trình phân tích (parser) tổng quát
cho phép lấy các nguồn cấp dữ liệu (feed) RSS hoặc Atom và dễ dàng truy
cập vào nội dung. Bởi vì hầu hết các nguồn thông tin trên Web đều có đầu
ra RSS hoặc Atom, Feedparser là một trong nhiều cách để đưa Raspberry Pi
kết nối với Internet of Things.
Trước tiên, cài đặt mô-đun Feedparser bằng Pip (xem phần “Dễ dàng cài đặt
mô-đun với Pip”ở trên):
sudo pip install feedparser
Để sử dụng nó, chỉ cần cung cấp chức năng parser URL của một RSS feed.
Feedparser sẽ tìm nạp XML của nguồn cấp dữ liệu, phân tích cú pháp và
chuyển nó thành cấu trúc dữ liệu danh sách đặc biệt được gọi là dictionary.
Dictionary Python là danh sách các cặp khóa/giá trị, đôi khi được gọi là hash
hoặc mảng kết hợp. Feed được phân tích cú pháp là dictionary, và các mục
được phân tích cú pháp trong feed cũng là dictionary, như được minh họa
trong ví dụ này, lấy thời tiết hiện tại ở Providence, RI, từ http://weather.gov/:
import feedparser
feed_url = "http://w1.weather.gov/xml/current_obs/KPVD.rss"
feed = feedparser.parse(feed_url)

RSSitems = feed["items"]
for item in RSSitems:
weather = item["title"]
print weather
Khởi chạy các Chương trình khác từ Python
Python dễ dàng trigger (kích khởi) chương trình khác trên Pi với mô-đun
sys.subprocess. Hãy thử những điều sau đây:
import subprocess
for count in range(0, 60):
filename = str(datetime.now()) + ".jpg"
subprocess.call(["fswebcam", filename])
sleep(60)
Đây là một script tạo chương trình time-lapse đơn giản sẽ chụp ảnh từ
webcam một phút một lần trong một giờ. Máy ảnh được trình bày chi tiết
hơn trong Chương 9, nhưng chương trình này sẽ hoạt động với máy ảnh
USB được kết nối và chương trình fswebcam được cài đặt; chạy lệnh này
trước để cài đặt nó:
sudo apt-get install fswebcam
Hàm subprocess.call nhận danh sách các chuỗi, kết hợp chúng lại với nhau
(với dấu cách) và thực thi chương trình được chỉ định. Nếu nó là một chương
trình hợp lệ, thì Raspberry Pi sẽ sinh ra một process riêng biệt cho nó, nó sẽ
chạy cùng với script Python. Lệnh trong ví dụ trước giống như khi gõ câu
lệnh sau tại dấu nhắc terminal:
fswebcam 20140812.jpg
Để thêm các tham số khác vào hàm gọi chương trình, chỉ cần thêm các chuỗi
vào danh sách trong hàm subprocess.call:
subprocess.call(["fswebcam", "-r", "1280x720", filename])
Điều này sẽ gửi chương trình fswebcam một tham số để thay đổi độ phân
giải của hình ảnh được chụp.

ungdungmaytinh.com
Tự động thực thi một script Python lúc khởi động
Bởi vì Pi có thể hoạt động như một thiết bị độc lập, một câu hỏi phổ biến là
làm thế nào để khởi chạy một chương trình Python tự động khi Pi khởi động.
Câu trả lời là thêm một mục vào file /etc/rc.local, để sử dụng cho chính xác
điều này trong Linux. Chỉ cần chỉnh sửa file:
sudo nano /etc/rc.local
và thêm một lệnh để thực thi script giữa section chú-thích và exit 0:
python /home/pi/foo.py&
Ký hiệu “&” ở cuối sẽ chạy script như một process nền, nó sẽ cho phép tất
cả các dịch vụ khác của Pi bắt đầu khởi động.
Khắc phục Sự cố
Chắc chắn, bạn sẽ gặp rắc rối khi viết code, sẽ cần theo dõi và sửa lỗi. Chế
độ tương tác IDLE có thể giúp tìm lỗi; menu Debug cung cấp một số công
cụ giúp biết code đang thực thi thế nào. Có thể tùy chọn xem tất cả các biến
và kiểm tra qua từng dòng thực hiện.
Lỗi cú pháp là lỗi dễ giải quyết nhất; thường thì đây chỉ là lỗi đánh máy hoặc
lỗi chính tả của ngôn ngữ. Lỗi ngữ nghĩa –chương trình được viết đúng cách
nhưng không hoạt động như mong đợi có thể khó sửa hơn. Đó là nơi trình
gỡ lỗi có thể giúp giải quyết một lỗi phức tạp. Việc gỡ lỗi hiệu quả mất nhiều
năm để tìm hiểu, nhưng đây là một bảng điều khiển nhanh để kiểm tra khi
lập trình Pi bằng Python:
• Sử dụng print() để hiển thị khi chương trình đến một điểm cụ thể.
• Sử dụng print() để hiển thị các giá trị của các biến khi chương trình
thực thi.
• Kiểm tra lại khoảng trắng để đảm bảo các khối lệnh được định nghĩa
đúng như ý bạn.
• Khi gỡ lỗi cú pháp, hãy nhớ rằng lỗi thực tế đã được chỉ ra trước khi
trình biên dịch báo cáo lỗi đó.
• Kiểm tra kỹ tất cả các biến toàn cục và cục bộ.
• Kiểm tra các dấu ngoặc đã đủ cặp chưa.

• Hãy chắc chắn rằng thứ tự của các phép toán là chính xác; thêm dấu
ngoặc đơn nếu không chắc chắn. Ví dụ: 3 + 4 *2 và (3 + 4) * 2 cho
kết quả khác nhau.

ungdungmaytinh.com
Chương 5
Arduino và Pi
Như sẽ thấy trong một vài chương tiếp theo, bạn có thể sử dụng các chân
GPIO trên Raspberry Pi để kết nối với các cảm biến hoặc những thứ như
LED nhấp nháy và động cơ. Và nếu có kinh nghiệm sử dụng board phát
triển Arduino, cũng có thể sử dụng nó cùng với Raspberry Pi.
Khi Raspberry Pi lần đầu tiên được công bố, rất nhiều người hỏi đó có phải
là đối thủ của Arduino không. Đối với cùng một mức giá, Pi cung cấp nhiều
tính năng xử lý hơn: tại sao sử dụng Arduino khi đã có một Pi? Vì có hai nền
tảng có thể bổ sung cho nhau, và Raspberry Pi có thể làm host (máy chủ) rất
tốt cho Arduino. Có khá nhiều dự án kết hợp Arduino và Pi lại với nhau:
• Sử dụng số lượng lớn các thư viện và các ví dụ chia sẻ cho Arduino.
• Để bổ sung một dự án Arduino với khả năng xử lý nhiều hơn. Ví dụ,
bạn có một bộ điều khiển MIDI đã được nối với một bộ tổng hợp,
nhưng bây giờ cần nâng cấp để tổng hợp âm thanh trực tiếp trên Pi.
• Khi bạn đang làm việc với mức logic 5V. Pi hoạt động với nguồn 3.3V,
và nó không thể chịu được áp 5V. Arduino có thể hoạt động như một
“bộ dịch tín hiệu” giữa hai nguồn.
• Khi làm thí nghiệm có thể làm cho một số lỗi gây tổn hại cho chip. Ví
dụ, nhiều sinh viên cố gắng điều khiển động cơ trực tiếp từ các chân
trên Arduino (đừng thử!); với chip (chân cắm) trên board Arduino,
khi bị hư hại, bạn dễ dàng tháo ra để thay chip khác, với giá rất rẻ.
Với Paspberry Pi thì sẽ không được như vậy.
• Khi gặp sự cố yêu cầu điều khiển chính xác trong thời gian thực,
chẳng hạn như bộ điều khiển cho máy in 3D. Như trong Chương 4,
Raspbian không phải là một hệ điều hành thời gian thực, và các
chương trình không thể phụ thuộc vào nguyên tắc “một câu lệnh
trong mỗi xung nhịp” của vi điều khiển.

Các ví dụ trong phần này giả định rằng bạn đã biết những điều cơ bản về
Arduino và môi trường phát triển tích hợp (IDE).
Hình 5-1. Arduino và Raspberry Pi là BFF (Best Friend Forever)
Cài đặt Arduino trong Raspbian
Để lập trình một board phát triển Arduino, cần kết nối nó với một máy tính
bằng cáp USB, sau đó biên dịch và flash một chương trình lên board bằng
cách sử dụng Arduino IDE. Có thể làm điều này với bất kỳ máy tính nào,
hoặc có thể sử dụng Raspberry Pi làm host để lập trình Arduino.
Sử dụng Raspberry Pi để lập trình Arduino sẽ nhanh hơn để gỡ lỗi, nhưng
việc biên dịch sẽ chậm hơn một chút so với một máy tính cá nhân hiện đại.
Việc biên dịch sẽ mất ít thời gian hơn sau lần biên dịch đầu tiên, vì Arduino
chỉ biên dịch những đoạn code đã thay đổi kể từ lần biên dịch cuối cùng.
Để cài đặt Arduino IDE trên Raspberry Pi, hãy nhập như sau vào terminal:
sudo apt-get update 
sudo apt-get install arduino 
 Đảm bảo có phiên bản phần mềm mới nhất
 Sau đó tải nó xuống.
Nó sẽ cài đặt Java cộng với nhiều phần kèm theo khác. Môi trường Arduino
sẽ xuất hiện dưới phần Electronics của menu chương trình (hãy khoan khởi
động nó).

ungdungmaytinh.com
Bạn có thể cắm Arduino vào một trong các cổng USB mở. Kết nối USB sẽ
cung cấp đủ nguồn cho Arduino, nhưng bạn cũng có thể cấp nguồn riêng
cho Arduino, tùy thuộc vào ứng dụng (ví dụ như đang chạy động cơ hoặc
máy sưởi).

Lưu ý rằng cần phải cắm cáp USB Arduino vào sau khi Raspberry
Pi khởi động. Nếu cắm vào lúc khởi động, Raspberry Pi có thể treo
vì nó cố gắng tìm ra tất cả các thiết bị trên bus USB.
Khi khởi động Arduino IDE, nó sẽ kiểm tra tất cả các thiết bị USB và liệt kê
một danh sách được hiển thị trong menu Tools → Serial Port. Nhấp vào
Tools→Serial Port và chọn cổng serial (thường sẽ là /dev/ttyACM0), sau đó
nhấp vào Tools → Board và chọn loại Arduino Board (ví dụ: Uno). Nhấp
vào File→Examples→01.Basics→Blink để tải code mẫu cơ bản. Nhấp vào
nút Upload trên thanh công cụ hoặc chọn File → Upload để nạp code và sau
khi nạp code, LED trên board Arduino sẽ bắt đầu nhấp nháy.

Để truy cập vào các cổng serial trên các phiên bản Raspbian cũ hơn
bản Jessie, bạn cần chắc rằng người dùng cấp pi được cấp quyền thực
hiện. Việc cấp quyền này có thể thực hiện bằng cách thêm người dùng
cấp pi vào nhóm tty và dialout. Bạn cần tiến hành trước khi cho chạy
Arduino IDE:
sudo usermod  -a –G  tty pi
sudo usermod -a -G dialout pi
 usermod là một chương trình Linux để quản lý người dùng
 -a –G đưa người dùng (pi) vào nhóm chỉ định (tty, rồi
dialout)
Tìm Serial Port
Nếu vì một lý do nào đó, /dev/ttyACM0 không hoạt động, bạn cần thực hiện
chút việc tra soát. Để tìm cổng serial USB mà Arduino được cắm vào mà
không cần tìm trong menu, hãy thử làm với command line. Hãy khoan kết
nối Arduino, bạn gõ:
ls /dev/tty*
Cắm Arduino, rồi thử lại lệnh tương tự và xem điều gì thay đổi. Trên
Raspberry Pi, ban đầu /dev/ttyAMA0 được liệt kê (đây là hub USB onboard).
Khi cắm vào Arduino, /dev/ttyACM0 xuất hiện trong bản kê (listing).

Cải thiện Kinh nghiệm Người dùng
Trong khi đang thiết lập, có thể nhận thấy rằng chất lượng của phông chữ
mặc định trong editor của Arduino là kém lý tưởng. Có thể thay đổi nó bằng
cách tải xuống phông chữ nguồn mở Inconsolata. Để cài đặt (khi Arduino
IDE đóng), hãy nhập:
sudo apt-get install ttf-inconsolata
Sau đó chỉnh sửa file tùy chọn Arduino:
nano ~/.arduino/preferences.txt
và thay đổi các dòng sau thành:
editor.font=Inconsolata,medium,14
editor.antialias=true
Khi khởi động lại Arduino, trình soạn thảo sẽ sử dụng phông chữ mới.
Giao tiếp bằng Serial
Để giao tiếp giữa Raspberry Pi và Arduino qua kết nối serial, sử dụng thư
viện Serial được tích hợp sẵn trong Arduino và mô-đun Python pySerial ở
bên Rasp Pi. Nó được cài đặt sẵn trên Jessie, nhưng nếu cần cài đặt nó, tên
của package đó là:
sudo apt-get install python-serial python3-serial
Mở IDE Arduino và tải code này lên Arduino:
void setup() {
Serial.begin(9600);
}
void loop() {
for (byte n = 0; n < 255; n++) {
Serial.write(n);
delay(50);
}
}
Nó sẽ đếm tới và gửi từng số qua kết nối serial.

Lưu ý rằng trong Arduino, Serial.write() cho ra số, sẽ được biên
dịch dưới dạng mã ký tự ASCII. Nếu muốn in chuỗi “123” thay vì
số 123, sử dụng lệnh Serial.print().

ungdungmaytinh.com
Tiếp theo, cần biết cổng serial USB nào Arduino được kết nối (xem “Tìm
cổng Serial” ở phần trước). Trong script Python này; nếu cổng không phải
là /dev/ttyACM0, hãy đổi giá trị của port. (Xem Chương 4 để biết thêm về
Python). Lưu nó thành SerialEcho.py và chạy với lệnh python SerialEcho.py:
import serial
port = "/dev/ttyACM0"
serialFromArduino = serial.Serial(port,9600) 
serialFromArduino.flushInput() 
while True:
if (serialFromArduino.inWaiting() > 0):
input = serialFromArduino.read(1) 
print(ord(input)) 
 Mở Serial Port được kết nối với Arduino.
 Xóa bộ đệm đầu vào.
 Đọc một byte từ serial buffer.
 Thay đổi byte vào thành một số thực ord().

Bạn không thể nạp lên Arduino khi Python mở serial port, vì vậy
hãy đảm bảo đã xóa chương trình Python bằng Ctrl-C trước khi nạp
code. Có thể nạp lên một Arduino Leonardo hoặc Arduino Micro,
nhưng làm vậy sẽ phá vỡ kết nối với script Python, vì vậy sẽ cần
phải khởi động lại bằng cách nào đó.
Arduino sẽ gửi một con số đến script Python, mà sẽ được thông dịch thành
một chuỗi. Biến input sẽ chứa bất kỳ ký tự nào trỏ tới số đó trong bảng
ASCII. Để có ý tưởng tốt hơn, hãy thử thay thế dòng cuối cùng của tập lệnh
Python bằng cách này:
print(str(ord(input)) + " = the ASCII character " + input + ".")
Đặt Serial Port làm Đối số
Nếu muốn đặt cổng làm đối số dòng lệnh, hãy sử dụng mô-đun sys để lấy
đối số đầu tiên:

import serial, sys
if (len(sys.argv) != 2):
print("Usage: python ReadSerial.py port")
sys.exit()
port = sys.argv[1]
Sau đó chạy chương trình:
python SerialEcho.py /dev/ttyACM0
Ví dụ đơn giản đầu tiên chỉ gửi một byte đơn; điều này có thể sẽ tốt hơn nếu
chỉ gửi một loạt code từ Arduino. Ví dụ, nếu chuột trái được bấm, gửi 1; nếu
là chuột phải, gửi 2. Tuy nhiên, nó chỉ hoạt động tốt cho 255 event rời rạc;
nhưng thường thì bạn lại muốn gửi những số lớn bất kỳ hoặc là chuỗi tùy ý.
Ví dụ, nếu đang đọc cảm biến analog với Arduino, có thể gửi các số trong
khoảng 0 đến 1.023.
Phân tích cú pháp các số tùy ý có trong một byte tại một thời điểm có thể
phức tạp hơn khi phân tích bằng các ngôn ngữ khác nhưng với cách Python
và pySerial xử lý chuỗi làm cho nó trở nên dễ dàng hơn. Ví dụ đơn giản, cập
nhật Arduino với code tiếp theo có giá trị từ 0 đến 1.024:
void setup() {
Serial.begin(9600);
}
void loop() {
for (int n = 0; n < 1024; n++)
Serial.println(n, DEC);
delay(50);
}
}
Điểm khác biệt chính là trong lệnh println(). Ở ví dụ trước, hàm
Serial.write() được dùng để ghi số vào cổng serial. Với println(),
Arduino định dạng số này thành chuỗi thập phân và gửi mã ASCII cho
chuỗi. Vì vậy, thay vì gửi một byte với giá trị 254, nó sẽ gửi chuỗi 254rn.
r thay cho trở về đầu dòng, và n là qua dòng mới (đây là những khái niệm
được chuyển từ máy đánh chữ vào máy tính: di chuyển đến đầu dòng; bắt
đầu một dòng văn bản mới).
Về phía Python, có thể sử dụng readline() thay vì read(), nó sẽ đọc tất cả
các ký tự cho đến khi (và bao gồm cả) dòng trả về và dòng mới. Python có

ungdungmaytinh.com
các hàm để chuyển đổi giữa các kiểu dữ liệu và chuỗi khác nhau. Chỉ có thể
sử dụng hàm int () để thay đổi chuỗi được định dạng thành một số nguyên:
import serial
port = "/dev/ttyACM0"
serialFromArduino = serial.Serial(port,9600)
serialFromArduino.flushInput()
while True:
input = serialFromArduino.readline()
inputAsInteger = int(input)
print(inputAsInteger * 10)
Lưu ý rằng nó chỉ đơn giản để thực hiện ví dụ này: nó sẽ đọc một đầu vào
analog và gửi kết quả; chỉ cần thay đổi vòng lặp:
void setup() {
Serial.begin(9600);
}
void loop() {
int n = analogRead(A0);
Serial.println(n, DEC);
delay(100);
}
Giả sử muốn thay đổi script Python chỉ cần nhập inputAsInteger thay vì
inputAsInteger * 10, nên nhập một giá trị bất kỳ trong khoảng 200 nếu
không có gì được kết nối với chân analog 0. Dùng dây điện, kết nối chân 0
đến GND và giá trị phải là 0. Kết nối nó với chân 3.3V thì giá trị vào khoảng
715, và là 1.023 khi kết nối với chân 5V.
Sử dụng thiết bị tương thích Arduino
Có rất nhiều board vi điều khiển tương thích với Arduino IDE. Một số sử
dụng adapter đặc biệt từ FTDI xử lý tất cả các giao tiếp serial USB-TTL. Để
kết nối với các board (thường rẻ hơn), có thể sử dụng cáp FTDI hoặc adapter
như USB BUB hoặc FTDI Friend. Trong bản Jessie, driver FTDI cho các board
chủ này đã được cài đặt, vì vậy chúng sẽ hoạt động ngay bóc hộp. Các board
này thường hiển thị dưới dạng thiết bị /dev/ttyUSB0.

Sử dụng Firmata
Khi vào sâu hơn, nhiều dự án sẽ trông như code cho giao tiếp cơ bản. Như
với bất kỳ hình thức giao tiếp nào, mọi thứ trở nên khó khăn khi sâu hơn
“Hello, world”; sẽ cần phải tạo các giao thức (hoặc tìm một giao thức hiện
có và thực hiện nó) để các bên hiểu nhau.
Một giải pháp tốt hơn đi kèm với Arduino là Firmata của Hans-Christoph
Steiner, một giao thức serial đa năng, đơn giản và dễ đọc. Nó có thể không
hoàn hảo cho mọi ứng dụng, nhưng nó tốt để bắt đầu. Dưới đây là ví dụ:
1. Chọn File → Examples → Firmata → StandardFirmata trong Arduino;
nó sẽ mở code Firmata mẫu cho phép gửi và nhận tin nhắn đến
Arduino và nhận thông tin về tất cả các chân.
2. Nạp code đó lên Arduino theo cách đã làm trong các ví dụ trước.
3. Cần code Python trên Pi gửi lệnh tới Arduino để truy vấn hoặc thay
đổi trạng thái của nó. Cách dễ nhất là dùng mô-đun pyFirmata. Cài
đặt nó với Pip (xem “Dễ dàng Cài đặt mô-đun với Pip” ở Chương 4):
sudo pip install pyfirmata
4. Bởi vì Firmata là một giao thức serial, bạn giao tiếp với Arduino từ
Python theo cách tương tự như trong các ví dụ trước, nhưng sử dụng
pyFirmata thay vì pySerial. Sử dụng method write() để tạo ra một
chân kỹ thuật số high hoặc low trên Arduino:
from pyfirmata import Arduino
board = Arduino('/dev/ttyACM0')
while (1):
board.digital[13].write(1)
print("on")
sleep(1)
board.digital[13].write(0)
print("off")
sleep(1)
Code này sẽ nhấp nháy LED trên board Arduino Uno được kết nối
với chân 13. Mô-đun đầy đủ trên trang pyFirmata GitHub.

ungdungmaytinh.com
Chương 6
Input và Output Cơ bản
Raspberry Pi, về bản chất là một máy tính Linux giá rất rẻ, có một vài khác
biệt giữa nó với máy tính cá nhân mà ta thường dùng để viết email, duyệt
web hoặc xử lý văn bản. Một trong những điểm khác biệt chính là Raspberry
Pi có thể được sử dụng trực tiếp trong các dự án điện tử, bởi vì nó có các
chân GPIO (input/output đa năng) trên board, như trong Hình 6-1.
Hình 6-1. Chân GPIO của Raspberry Pi
Các chân GPIO này có thể được truy cập để điều khiển phần cứng như LED,
động cơ và rơ-le, tất cả đều là các ví dụ về output. Đối với input, Raspberry
Pi có thể đọc trạng thái của các nút, công tắc, và vành chia độ, hoặc nó có thể
đọc cảm biến như nhiệt độ, ánh sáng, chuyển động hoặc tiệm cận,…

Với sự ra đời của Raspberry Pi 1 Model B+, số lượng chân GPIO
tăng từ 26 lên 40. Nếu có Raspberry Pi cũ hơn, vẫn có thể thực hiện
các ví dụ trong chương này vì chúng sẽ chỉ sử dụng 26 chân đầu
tiên trên GPIO.
Ưu điểm của việc có một máy tính với các chân GPIO là có thể tạo các
chương trình để đọc các đầu vào và điều khiển đầu ra dựa trên nhiều điều

kiện khác nhau, dễ dàng như lập trình máy tính cá nhân. Không giống như
board vi điều khiển điển hình, cũng có các chân GPIO lập trình, Raspberry
Pi có thêm một số đầu vào và đầu ra, chẳng hạn như bàn phím, chuột và
màn hình, cũng như cổng Ethernet, có thể hoạt động như cả đầu vào và đầu
ra. Nếu có kinh nghiệm tạo ra các dự án điện tử với các board vi điều khiển
như Arduino, có thể thêm một vài đầu vào và đầu ra theo ý với Raspberry
Pi. Ưu điểm lớn nhất là chúng được tích hợp sẵn; không cần phải nối thêm
bất kỳ mạch điện nào để sử dụng chúng.
Có bàn phím, chuột, và màn hình không phải là lợi thế duy nhất Raspberry
Pi hơn các board vi điều khiển điển hình. Có một vài tính năng chính khác
sẽ giúp cho các dự án điện tử:
Hệ thống file
Việc có thể đọc và ghi dữ liệu trong hệ thống file Linux sẽ làm cho
nhiều dự án trở nên dễ dàng hơn nhiều. Ví dụ, bạn có thể kết nối cảm
biến nhiệt độ với Raspberry Pi và đọc nó một lần mỗi giây. Mỗi lần
đọc có thể được nối vào cuối một file log, có thể dễ dàng tải xuống và
phân tích cú pháp trong chương trình vẽ đồ thị. Nó thậm chí có thể
được vẽ đồ thị ngay trên chính Raspberry Pi!
Công cụ Linux
Tích hợp trong phiên bản Linux của Raspberry Pi là một tập hợp các
tiện ích command-line cốt lõi, cho phép làm việc với các file, kiểm soát
các process và tự động hóa nhiều tác vụ khác nhau. Và bởi vì có một
cộng đồng người dùng Linux rất lớn sử dụng các tiện ích cốt lõi này,
bạn dễ dàng tìm được sự giúp đỡ bằng cách tìm kiếm trên các website.
Để được trợ giúp chung về Linux, bạn thường có thể tìm thấy câu trả
lời tại Stack Overflow. Nếu có một câu hỏi cho Raspberry Pi, hãy thử
Raspberry Pi Forum hoặc mục Raspberry Pi của Stack Overflow.
Ngôn ngữ
Có rất nhiều ngôn ngữ lập trình, và các hệ thống Linux nhúng như
Raspberry Pi mang lại sự linh hoạt để lựa chọn ngôn ngữ nào bạn
thấy dễ chịu nhất. Các ví dụ trong cuốn sách này sử dụng shell script
và Python, nhưng chúng có thể dễ dàng được dịch sang các ngôn ngữ
như C, Java hoặc Perl.

ungdungmaytinh.com

Một trong những hạn chế của Raspberry Pi là không có cách nào để
kết nối trực tiếp các cảm biến analog, như là cảm biến ánh sáng và
nhiệt độ. Để kết nối cần một con chip được gọi là bộ chuyển đổi
analog-digital hoặc ADC. Xem Chương 8 để biết cách đọc các tín
hiệu analog bằng ADC.
Sử dụng Input và Output
Bạn cần có thêm một số chi tiết nữa ngoài board Raspberry Pi để thực hành
những bài hướng dẫn input và output cơ bản này. Dưới đây là một số linh
kiện cơ bản, bạn dễ dàng tìm mua ở các cửa hàng điện tử:
• Breadboard
• LED
• Dây cắm đực-đực
• Dây cắm đực-cái
• Công tắc nhấn
• Điện trở
Để giúp dễ dàng kết nối các linh kiện từ breadboard vào các chân của
Raspberry Pi, nên sử dụng bộ Kit Breakout Pi Cobbler (của Adafruit), kết
nối tất cả các chân GPIO đến breadboard với một cáp ribbon đơn. Với board
này, bạn không cần sử dụng dây nối đực-cái.
Trong Hình 6-2, từng chân trên board Raspberry Pi đã được gắn nhãn theo
số tín hiệu GPIO mặc định của nó, đó là cách bạn chỉ đến một chân cụ thể
trong các lệnh thực thi và trong code. Các chân không có gắn nhãn được
dành cho các chức năng khác theo mặc định.

Hình 6-2. Các chân GPIO mặc định trên Raspberry Pi. Một số chân còn trống cũng có
thể được sử dụng như GPIO, nhưng chúng có thể có các chức năng khác. Trừ khi bạn
cần nhiều hơn các chân GPIO được liệt kê ở đây, hãy khoan động đến chúng.
Có một trang web tiện dụng được tạo ra bởi Phil Howard gọi là Raspberry
Pinout. Nó sẽ hiển thị các chân GPIO của Raspberry Pi và có rất nhiều thông
tin tham khảo về cách chúng có thể được sử dụng.
Ngoài ra còn có các sản phẩm tuyệt vời như board RasPiO Portsplus Port
ID, thể hiện trong hình 6-3. Đó là một board nhỏ phù hợp với các chân GPIO
cho mục đích duy nhất là làm cho các chân nhận biết dễ dàng hơn.

ungdungmaytinh.com
Hình 6-3. Board RasPiO Portsplus Port ID
Output Digital: Bật sáng LED
Cách dễ nhất để sử dụng các đầu ra bằng các chân GPIO là kết nối một LED.
Sau đó có thể sử dụng command line Linux để bật và tắt LED. Khi đã hiểu
được cách các lệnh này hoạt động, bạn sẽ phát triển nó thêm để LED sáng
lên khi nào có email mới, khi cần mang theo dù khi rời khỏi nhà hoặc khi đã
đến lúc đi ngủ. Có thể phát triển các dự án khác với LED cơ bản và ví dụ sử
dụng một rơle để điều khiển một đèn theo lịch trình thiết lập.
Hướng dẫn cho người mới sử dụng Breadboard
Nếu chưa bao giờ sử dụng breadboard (Hình 6-4) dưới đây, điều quan trọng
là phải biết thiết bị terminal nào được kết nối. Trong hình đã bôi đen các kết
nối terminal trên một breadboard thông thường. Lưu ý rằng các bus nguồn
ở bên trái không được kết nối với các bus nguồn ở bên phải của board. Sẽ
phải sử dụng dây nối đực-đực để kết nối chúng với nhau nếu cần nối đất
hoặc điện áp nguồn ở cả hai bên của breadboard.

Hình 6-4. Breadboard
Dưới đây là hướng dẫn:
1. Dùng dây đực-cái, kết nối chân 25 trên Raspberry Pi với breadboard.
Tham khảo Hình 6-2 cho vị trí của từng chân trên hàng rào GPIO của
Raspberry Pi.
2. Sử dụng dây nối khác, kết nối chân đất của Raspberry Pi với bus
nguồn âm (−) trên breadboard.
3. Bây giờ kết nối LED (xem Hình 6-5). Trước khi làm điều đó, điều quan
trọng cần biết rằng LED là có cực tính! Trong hai chân ra của đèn LED,
chân dài hơn là chân dương (anode, A, hoặc “cộng”) và được nối với
một chân GPIO. Chân ngắn hơn là chân âm (cathode, K, hoặc “trừ”)
và phải được nối với đất. Nối chân dương của LED vào breadboard
sao cho nối tiếp với dây điện từ chân 25. Nối chân âm của LED vào
bus nguồn âm (−) của breadboard.

ungdungmaytinh.com
 Một cách để dễ nhớ cực tính của LED là chân “cộng” của nó dài hơn
chân “trừ”.
Hình 6-5. Nối LED với Raspberry Pi
4. Khi bàn phím, chuột và màn hình đã được kết nối, hãy bật nguồn
Raspberry Pi và đăng nhập. Nếu đang ở trong môi trường Window
X, bạn nhấp đúp vào biểu tượng LXTerminal trên màn hình. Nó sẽ
dẫn đến cửa sổ terminal.
5. Để truy cập các chân input và output từ command line, cần chạy các
lệnh với quyền root, là tài khoản superuser trên Raspberry Pi. Để bắt
đầu thực thi lệnh với quyền root, gõ sudo su vào command line và
nhấn Enter:
pi@raspberrypi ~ $ sudo su
root@raspberrypi:/home/pi#
Dấu nhắc lệnh sẽ thay đổi từ $ thành #, cho biết hiện đang chạy lệnh
với quyền root.

Tài khoản root có quyền truy cập quản trị vào tất cả các hàm và file
trên hệ thống và không thể bảo vệ khỏi việc làm hỏng hệ điều hành
nếu gõ lệnh có thể gây hại cho nó. Phải thận trọng khi chạy lệnh với
quyền root. Nếu làm điều gì đó lộn xộn, đừng lo lắng quá nhiều; có
thể chép lại ảnh vào thẻ SD bằng cách cài đặt Linux kiểu “clean”; tuy

nhiên, sẽ mất các tùy chỉnh đã thực hiện trong hệ điều hành, cũng
như bất kỳ chương trình hoặc sketch đã viết.
Khi làm việc xong trong tài khoản root, hãy gõ exit để trở lại làm
việc trong tài khoản người dùng pi.
6. Trước khi có thể sử dụng command line để bật/tắt LED trên chân 25,
cần phải đặt chân vào vùng người dùng (nói cách khác, làm cho chân có
sẵn để sử dụng bên ngoài giới hạn của Linux), theo cách này:
root@raspberrypi:/home/pi# echo 25 > /sys/class/gpio/export
Lệnh echo ghi số chân muốn dùng (25) vào file xuất, nằm trong thư
mục /sys/class/gpio. Khi ghi số chân vào file đặc biệt này, nó sẽ tạo một
thư mục mới trong /sys/class/gpio có các file điều khiển cho chân. Với
trường hợp này, nó tạo một thư mục mới với tên /sys/class/gpio/gpio25.
7. Chuyển đến thư mục đó bằng lệnh cd và liệt kê nội dung của nó bằng
ls:
root@raspberrypi:/home/pi# cd /sys/class/gpio/gpio25
root@raspberrypi:/sys/class/gpio/gpio25# ls
active_low direction edge power subsystem uevent value
Lệnh cd là viết tắt của “change directory”. Nó thay đổi thư mục làm
việc để không phải nhập đường dẫn đầy đủ cho mỗi file. ls sẽ liệt kê
các file và thư mục trong thư mục đó. Có hai file sẽ làm việc trong thư
mục này: direction và value.
8. File direction chỉ cách đặt chân này làm đầu vào (như một nút) hoặc
đầu ra (như LED). Vì có LED được nối với chân 25, muốn điều khiển
nó cần đặt chân này làm đầu ra:
root@raspberrypi:/sys/class/gpio/gpio25# echo out > direction
9. Để bật LED, sử dụng lại lệnh echo để ghi số 1 vào file value:
root@raspberrypi:/sys/class/gpio/gpio25# echo 1 > value
10. Sau khi nhấn Enter, LED sẽ bật! Tắt nó cũng đơn giản bằng cách sử
dụng echo để ghi zéro vào file value:
root@raspberrypi:/sys/class/gpio/gpio25# echo 0 > value

ungdungmaytinh.com
File ảo
Các file đang làm việc không thực sự là các file trên thẻ SD của Raspberry
Pi, mà là một phần của hệ thống file ảo của Linux, đó là một hệ thống giúp dễ
dàng truy cập các hàm cấp thấp của board theo cách đơn giản hơn. Ví dụ,
có thể bật và tắt LED bằng cách ghi một section cụ thể vào bộ nhớ Raspberry
Pi, nhưng làm như vậy sẽ yêu cầu thêm code và thêm lưu ý.
Vì vậy, nếu ghi vào một file là cách điều khiển các thành phần đầu ra, làm
thế nào để kiểm tra trạng thái của các thành phần đầu vào? Nếu đoán “đọc
một file” thì hoàn toàn đúng. Hãy thử ngay bây giờ.
Input Digital: Đọc một nút
Các nút nhấn đơn giản giống như trong Hình 6-6 để điều khiển đầu vào
digital cơ bản. Ưu điểm là chúng được thiết kế để gắn vừa vào một
breadboard.

Các nút nhỏ này thường được sử dụng trong các dự án điện tử và
hiểu nguyên lý hoạt động bên trong chúng sẽ giúp thực hiện dự án
dễ dàng hơn. Nhìn vào nút khi nó nằm trong breadboard (xem Hình
6-6), hai terminal luôn được kết nối với nhau ở cả hai bên của nút
bấm. Khi nhấn nút, hai bộ thiết bị termial này được kết nối với nhau.
Hình 6-6. Nút
Khi đọc đầu vào digital trên Raspberry Pi, hãy kiểm tra xem liệu chân có
được kết nối với 3,3 V hoặc xuống đất không. Một khi đã hiểu được đầu vào
digital với một nút bấm hoạt động thế nào, có thể bắt đầu các dự án như

công tắc bảo mật từ, joystick máy chơi game, hoặc thậm chí là máy bán hàng
tự động. Bắt đầu bằng cách kết nối một công tắc để đọc trạng thái của nó:
1. Gắn nút vào breadboard để các chân của nó nằm giữa breadboard.
2. Sử dụng dây điện, kết nối chân 24 từ Raspberry Pi đến một trong các
chân của nút.
3. Nối chân 3,3V từ Raspberry Pi với bus nguồn dương trên breadboard.
 Hãy đảm bảo nối nút với chân 3,3V chứ không phải là chân 5V. Điện
áp trên 3,3 V đưa vào đầu vào sẽ làm hỏng vĩnh viễn Raspberry Pi.
4. Nối một trong một chân dưới của nút với bus nguồn âm. Bây giờ khi
nhấn nút, nguồn 3,3 V sẽ được kết nối với chân 24.
5. Khi buông nút, chân 24 không được kết nối với áp 3,3 V hoặc đất, nên
tín hiệu trên chân này ở vào trạng thái float (lưng chừng). Điều này sẽ
gây ra kết quả không mong muốn, vì vậy, hãy khắc phục điều đó. Sử
dụng điện trở 10K (mã màu: nâu, đen, cam và sau đó là bạc hoặc vàng)
để kết nối đầu vào của công tắc với đất, đã kết nối với đất của
Raspberry Pi trong ví dụ đầu ra. Khi công tắc không được nhấn, chân
sẽ được nối với đất.
Dòng điện luôn đi từ cực dương sang cực âm, vì vậy khi nhấn công
tắc, áp 3,3 V sẽ đi về phía đầu vào của Raspberry Pi, có điện trở ít hơn
điện trở 10K. Khi nối dây xong, nó sẽ giống như Hình 6-7.
6. Bây giờ mạch đã được lắp, hãy đọc giá trị của chân từ command line.
Nếu chưa thực thi lệnh với quyền root, hãy nhập sudo su.
7. Như với ví dụ trước, cần đặt chân input vào không gian người dùng:
# echo 24 > /sys/class/gpio/export
8. Hãy thay đổi thư mục đã được tạo trong quá trình xuất:
# cd /sys/class/gpio/gpio24
9. Bây giờ thiết lập hướng của chân đầu vào:
# echo in > direction

ungdungmaytinh.com
Hình 6-7. Kết nối một nút đến Raspberry Pi
10. Để đọc giá trị của chân, sử dụng lệnh cat, sẽ in nội dung của file vào
thiết bị terminal. Lệnh cat được sử dụng vì nó cũng có thể được sử
dụng để nối, sắp xếp. Nó cũng có thể hiển thị nội dung của một file:
# cat value
0
11. Bây giờ nhấn và giữ nút trong khi thực hiện lại lệnh:
# cat value
1
12. Nếu thấy số 1 thì chương trình đúng.
 Để dễ dàng thực hiện lệnh đã thực thi trước đó, hãy nhấn phím
mũi tên lên cho đến khi thấy lệnh muốn chạy và sau đó nhấn Enter.
Bây giờ có thể sử dụng dòng lệnh Linux để điều khiển LED hoặc đọc trạng
thái của nút, hãy sử dụng một vài công cụ tích hợp của Linux để tạo một dự
án đơn giản sử dụng đầu vào và đầu ra digital.

Dự án: Cron Lamp Timer
Giả sử bạn sắp đi công tác, và muốn kẻ trộm đừng dòm ngó đến nhà bạn.
Đèn hẹn giờ là một biện pháp ngăn chặn tốt, nhưng các cửa hàng điện tử
không mở của vào ban đêm và ngày mai lại phải đi sớm. Tuy nhiên, nếu sở
hữu Raspberry Pi, có thể tự làm bằng những linh kiện cụ thể là:
• Board Raspberry Pi
• Breadboard
• Dây đực cái
• Rơ-le PowerSwitch Tail II
• Dây nối
Với các linh kiện này, có thể tạo đèn lập trình hẹn giờ bằng cách sử dụng hai
công cụ Linux: script shell và cron.
Script lệnh
Một script shell là một file có chứa một loạt lệnh (giống như các file đã sử
dụng để kiểm soát và đọc các chân). Hãy xem script shell sau đây và giải
thích về các dòng chính:
#!/bin/bash 
echo Exporting pin $1. 
echo $1 > /sys/class/gpio/export 
echo Setting direction to out.
echo out > /sys/class/gpio/gpio$1/direction 
echo Setting pin high.
echo 1 > /sys/class/gpio/gpio$1/value
 Dòng này là bắt buộc đối với tất cả các tập lệnh shell.
 $1 đề cập đến đối số dòng lệnh đầu tiên.
 Thay vì xuất một số chân cụ thể, tập lệnh sử dụng đối số dòng lệnh
đầu tiên.
 Lưu ý rằng đối số dòng lệnh đầu tiên cũng thay thế số chân ở đây.
Lưu file đó dưới dạng file văn bản có tên on.sh và làm cho file có thể thực thi
bằng lệnh chmod:
root@raspberrypi:/home/pi# chmod +x on.sh

ungdungmaytinh.com
 Cần thực hiện các lệnh này với quyền root. Nhập sudo su nếu nhận
được lỗi như “Permission denied.”
Một đối số command-line là một cách để truyền thông tin vào một chương
trình hoặc script bằng cách gõ nó vào sau tên của lệnh. Khi viết một scsript
shell, $ 1 đề cập đến đối số command-line đầu tiên, $ 2 là đối số thứ hai,
v.v. Trong trường hợp on.sh, nhập số chân muốn xuất và bật. Thay vì code
“cứng” chân 25 vào trong script shell, nó phổ biến hơn bằng cách dẫn đến
chân đã được gõ vào dòng lệnh. Để xuất chân 25 và bật, có thể nhập:
root@raspberrypi:/home/pi/# ./on.sh 25 
Exporting pin 25.
Setting direction to out.
Setting pin high.
 ./ trước tên file cho biết đang thực thi tập lệnh trong thư mục đang
hiển thị.
Nếu vẫn có LED kết nối với chân 25 từ trước đó trong chương, nó sẽ bật.
Hãy tạo một script shell khác có tên off.sh, nó sẽ tắt LED. Nó sẽ giống thế
này:
#!/bin/bash
echo Setting pin low.
echo 0 > /sys/class/gpio/gpio$1/value
echo Unexporting pin $1
echo $1 > /sys/class/gpio/unexport
Chạy tập lệnh:
root@raspberrypi:/home/pi/temp# chmod +x off.sh
root@raspberrypi:/home/pi/temp# ./off.sh 25
Setting pin low.
Unexporting pin 25
Nếu mọi thứ hoạt động, LED sẽ tắt.
Kết nối Đèn
Một chiếc LED nhỏ bé sẽ không phát ra đủ ánh sáng để đánh lừa kẻ trộm
khi nghĩ rằng có người ở nhà, vì vậy hãy kết nối đèn với Raspberry Pi:
1. Tháo LED được nối với chân 25.

2. Nối hai sợi dây điện với breadboard, một dây nối với chân 25 của
Raspberry Pi và cái kia vào bus nối đất.
3. Sợi dây kết nối với chân 25 phải được nối với đầu nối “+in” của rơ-le
PowerSwitch.
4. Sợi dây nối với đất phải được kết nối với đầu nối “−in” của rơ-le
PowerSwitch. Kiểm tra mạch với Hình 6-8.
5. Cắm rơ-le PowerSwitch vào ổ điện và cắm đèn vào rơ le PowerSwitch.
Đảm bảo công tắc của đèn ở vị trí bật.
6. Bây giờ khi thực thi ./on.sh 25, đèn sẽ bật; và nếu thực hiện; và với
./off.sh 25, đèn sẽ tắt!
Hình 6-8. Kết nối một PowerSwitch Tail II với Raspberry Pi

Bên trong PowerSwitch có một vài linh kiện điện tử giúp điều
khiển các thiết bị điện áp cao như đèn hoặc máy xay sinh tố bằng
cách sử dụng tín hiệu điện áp thấp như tín hiệu từ Raspberry Pi.
Tiếng “click” bạn nghe từ PowerSwitch Tail khi nó được bật
hoặc tắt là rơ-le, thành phần cốt lõi của mạch bên trong. Một rơ-
le hoạt động như một công tắc cho thiết bị cao áp có thể được bật
hoặc tắt tùy thuộc vào việc tín hiệu điều khiển điện áp thấp từ
Raspberry Pi đang bật hay tắt.
Lập lịch trình Thực thi Lệnh với cron
Khi đèn được nối với Raspberry Pi thông qua PowerSwitch Tail, bạn có thể
bật hoặc tắt đèn bằng một lệnh duy nhất. Bây giờ có thể sử dụng cron để lên
lịch cho đèn bật và tắt vào những thời điểm khác nhau trong ngày. cron là

ungdungmaytinh.com
trình lên lịch công việc của Linux. Với nó, có thể thiết lập các lệnh để thực
hiện vào các thời điểm và ngày cụ thể, hoặc có thể chạy trên một khoảng
thời gian cụ thể (ví dụ, mỗi giờ một lần). Bạn sẽ lên lịch hai công việc: thời
gian bật đèn (lúc 8:00pm) và thời gian tắt đèn (lúc 2:00am).

Cũng giống như các chương trình phụ thuộc vào thời gian khác,
bạn cần đảm bảo đã thiết lập ngày và giờ chính xác trên Raspberry
Pi, như được mô tả trong phần “Đặt ngày và giờ” ở Chương 2.
Để thêm các nhiệm vụ này, phải chỉnh sửa bảng cron (một danh sách các
lệnh mà Linux thực thi tại các thời điểm xác định):
root@raspberrypi:/home/pi/# crontab -e
Thao tác này sẽ khởi chạy text editor để thay đổi bảng cron của root (để thay
đổi thành người dùng root, hãy gõ sudo su). Ở đầu file, có một số thông tin
về cách sửa đổi bảng cron. Sử dụng phím mũi tên để đến cuối file và thêm
hai mục nhập này vào cuối file:
0 20 * * * /home/pi/on.sh 25
0 2 * * * /home/pi/off.sh 25

cron sẽ bỏ qua bất kỳ dòng nào bắt đầu bằng dấu hash (#). Nếu
muốn tạm thời vô hiệu hóa một dòng mà không xóa, hoặc thêm
nhận xét vào file, hãy đặt dấu hash ở trước dòng.
Nhấn Ctrl-X để thoát, nhấn y để lưu file khi được nhắc và nhấn Enter để
chấp nhận tên file mặc định. Khi file đã được lưu và bạn trở lại command
line, sẽ có dòng installing new crontab để báo rằng những thay đổi bạn
vừa thực hiện đã được cron thực thi.
Thêm về cron
cron sẽ cho phép lên lịch công việc cho ngày và giờ cụ thể, hoặc trong
khoảng thời gian. Có năm miền thời gian (hoặc sáu, nếu muốn lên lịch theo
năm), mỗi khoảng được phân tách bằng dấu cách và một khoảng trắng, sau
đó lệnh để thực thi; dấu hoa thị chỉ ra rằng công việc nên thực hiện từng giai
đoạn (Bảng 6-1).

Bảng 6-1. Nhập cron để bật đèn lúc 8:00 chiều mỗi ngày
0 20 * * * /home/pi/on.sh
Phút (:00) Giờ (8 p.m.) Hàng
ngày
Hàng
tháng
Tất cả các ngày
trong tuần
Đường dẫn đến
lệnh
Giả sử chỉ muốn đèn bật một số ngày trong tuần. Bảng 6-2 cho thấy mục
nhập crontab trông như thế nào.
Bảng 6-2. Nhập cron để bật đèn lúc 8:00 chiều mỗi ngày trong tuần
0 20 * * 1-5 /home/pi/on.sh25
Phút (:00) Giờ (8 p.m.) Hàng
ngày
Hàng
tháng
Từ thứ 2 đến
thứ 6
Đường dẫn đến
lệnh
Một ví dụ khác, giả sử có một tập lệnh shell để kiểm tra xem có thư mới và
gửi email. Bảng 6-3 cho thấy cách sẽ nhận tập lệnh đó chạy 5 phút một lần.
Bảng 6-3. Nhập cron để kiểm tra thư mỗi năm phút
*/5 * * * * /home/pi/checkMail.sh
Mỗi
5 phút
Hằng
giờ
Hàng
ngày
Hàng
tháng
Mọi ngày
trong tuần
Đường dẫn đến lệnh
Ký hiệu */5 cho biết khoảng thời gian 5 phút một lần.
cron là một công cụ mạnh mẽ theo ý người dùng để lên kế hoạch công việc
cho những ngày hoặc thời gian cụ thể và với các thông tin cụ thể.

[Demo] Bat dau lam quen voi Raspberry Pi

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to [Demo] Bat dau lam quen voi Raspberry Pi

Similar to [Demo] Bat dau lam quen voi Raspberry Pi (20)

More from Thien Ta

More from Thien Ta (6)

[Demo] Bat dau lam quen voi Raspberry Pi