Đầu ra hệ điều hành python

Tổng quan về bảng Raspberry Pi

Raspberry Pi có nhiều yếu tố hình thức cho các trường hợp sử dụng khác nhau. Trong hướng dẫn này, bạn sẽ xem xét phiên bản mới nhất, Raspberry Pi 4

Dưới đây là cách bố trí bo mạch của Raspberry Pi 4. Mặc dù cách bố trí này hơi khác so với các mẫu Raspberry Pi trước đây, nhưng hầu hết các kết nối đều giống nhau. Thiết lập được mô tả trong phần tiếp theo phải giống nhau cho cả Raspberry Pi 3 và Raspberry Pi 4

Bảng Raspberry Pi 4 chứa các thành phần sau

• Chân đầu vào-đầu ra đa năng. Các chân này được sử dụng để kết nối Raspberry Pi với các linh kiện điện tử

• Cổng mạng. Cổng này kết nối Raspberry Pi với mạng có dây. Raspberry Pi cũng được tích hợp Wi-Fi và Bluetooth cho các kết nối không dây

• Hai USB 3. 0 và hai USB 2. 0 cổng. Các cổng USB này được sử dụng để kết nối các thiết bị ngoại vi như bàn phím hoặc chuột. Hai cổng màu đen là USB 2. 0 và hai cổng màu xanh là USB 3. 0

• giắc cắm AV. Giắc cắm AV này cho phép bạn kết nối loa hoặc tai nghe với Raspberry Pi

• Cổng mô-đun máy ảnh. Cổng này được sử dụng để kết nối Mô-đun máy ảnh Raspberry Pi chính thức, cho phép Raspberry Pi chụp ảnh

• cổng HDMI. Các cổng HDMI này kết nối Raspberry Pi với màn hình bên ngoài. Raspberry Pi 4 có hai cổng micro HDMI, cho phép nó điều khiển hai màn hình riêng biệt cùng một lúc

• cổng nguồn USB. Cổng USB này cấp nguồn cho Raspberry Pi. Raspberry Pi 4 có cổng USB Type-C, trong khi các phiên bản Pi cũ hơn có cổng micro-USB

• Cổng hiển thị bên ngoài. Cổng này được sử dụng để kết nối màn hình cảm ứng Raspberry Pi bảy inch chính thức cho đầu vào dựa trên cảm ứng trên Raspberry Pi

• Khe cắm thẻ nhớ microSD [mặt dưới bo mạch]. Khe cắm thẻ này dành cho thẻ nhớ microSD chứa hệ điều hành Raspberry Pi và các tệp

Một lát sau trong hướng dẫn này, bạn sẽ sử dụng các thành phần ở trên để thiết lập Raspberry Pi của mình

Raspberry Pi so với Arduino

Mọi người thường tự hỏi sự khác biệt giữa Raspberry Pi và Arduino là gì. Arduino là một thiết bị khác được sử dụng rộng rãi trong điện toán vật lý. Mặc dù có một số điểm trùng lặp về khả năng của Arduino và Raspberry Pi, nhưng vẫn có một số khác biệt rõ rệt

Nền tảng Arduino cung cấp giao diện phần cứng và phần mềm để lập trình vi điều khiển. Bộ vi điều khiển là một mạch tích hợp cho phép bạn đọc đầu vào từ và gửi đầu ra đến các linh kiện điện tử. Các bo mạch Arduino thường có bộ nhớ hạn chế, vì vậy chúng thường được sử dụng để chạy lặp đi lặp lại một chương trình duy nhất tương tác với thiết bị điện tử

Raspberry Pi là một máy tính đa năng, dựa trên Linux. Nó có một hệ điều hành đầy đủ với giao diện GUI có khả năng chạy nhiều chương trình khác nhau cùng một lúc

Raspberry Pi đi kèm với nhiều phần mềm được cài đặt sẵn, bao gồm trình duyệt web, bộ ứng dụng văn phòng, thiết bị đầu cuối và thậm chí cả Minecraft. Raspberry Pi cũng được tích hợp Wi-Fi và Bluetooth để kết nối Internet và các thiết bị ngoại vi bên ngoài

Để chạy Python, Raspberry Pi thường là lựa chọn tốt hơn, vì bạn có được bản cài đặt Python chính thức mà không cần bất kỳ cấu hình nào

Phần cứng cần thiết

Cần có phần cứng sau đây để thiết lập ban đầu cho Raspberry Pi của bạn. Nếu bạn kết nối với Raspberry Pi qua SSH, bạn sẽ xem xét sau trong hướng dẫn này, thì một số phần cứng bên dưới sẽ không cần thiết sau khi thiết lập ban đầu

Phần cứng tùy chọn

Bạn có thể sử dụng toàn bộ phạm vi phần cứng bổ sung với Raspberry Pi để mở rộng khả năng của nó. Các mục phần cứng được liệt kê bên dưới không bắt buộc phải sử dụng Raspberry Pi của bạn nhưng sẽ hữu ích nếu bạn có sẵn

Phần mềm

Hệ điều hành cho Raspberry Pi được lưu trữ trên thẻ nhớ microSD. Nếu thẻ của bạn không đến từ bộ Raspberry Pi chính thức, thì bạn sẽ cần cài đặt hệ điều hành trên đó

Có nhiều cách để thiết lập hệ điều hành trên Raspberry Pi của bạn. Bạn có thể tìm hiểu thêm về các tùy chọn cài đặt khác nhau trên trang web Raspberry Pi

Trong phần này, bạn sẽ xem xét hai cách để cài đặt Raspbian, hệ điều hành Raspberry Pi được hỗ trợ chính thức, dựa trên Debian Linux

$ ssh pi@[IP ADDRESS]

Thiết lập cuối cùng

Bây giờ bạn đã có sẵn thẻ nhớ microSD và phần cứng cần thiết, bước cuối cùng là kết nối mọi thứ lại với nhau và định cấu hình hệ điều hành. Hãy bắt đầu bằng cách kết nối tất cả các thiết bị ngoại vi

1. Lắp thẻ nhớ microSD vào khe cắm thẻ ở dưới cùng của Raspberry Pi
2. Kết nối bàn phím và chuột với bất kỳ cổng nào trong bốn cổng USB
3. Kết nối màn hình với một trong các cổng HDMI bằng cáp HDMI dành riêng cho mẫu Raspberry Pi của bạn
4. Kết nối nguồn điện với cổng nguồn USB

Với các thiết bị ngoại vi được kết nối, hãy tiếp tục và bật Raspberry Pi của bạn để định cấu hình hệ điều hành. Nếu bạn đã cài đặt Raspbian với Raspberry Pi Imager, thì bạn không thể làm gì khác. Bạn có thể chuyển xuống phần tiếp theo để hoàn tất thiết lập

Nếu bạn đã cài đặt NOOBS trên thẻ SD thì bạn sẽ cần hoàn thành một vài bước nữa để cài đặt Raspbian trên thẻ SD

1. Đầu tiên, bật nguồn Raspberry Pi để tải giao diện NOOBS
2. Sau đó, đánh dấu vào hộp kiểm bên cạnh tùy chọn Raspbian trong danh sách phần mềm cần cài đặt
3. Cuối cùng, nhấn nút Install ở góc trên cùng bên trái giao diện để bắt đầu cài đặt Raspbian trên thẻ SD

Khi quá trình cài đặt hoàn tất, Raspberry Pi sẽ khởi động lại và bạn sẽ được khởi động vào Raspbian để hoàn tất trình hướng dẫn thiết lập

Sử dụng Trình chỉnh sửa Mu

Hệ điều hành Raspbian đi kèm với một số IDE Python được cài đặt sẵn mà bạn có thể sử dụng để viết chương trình của mình. Một trong những IDE này là Mu. Nó có thể được tìm thấy trong menu chính

Biểu tượng Raspberry Pi → Lập trình → Mu

Khi bạn mở Mu lần đầu tiên, bạn sẽ được cung cấp tùy chọn để chọn chế độ Python cho trình chỉnh sửa. Đối với mã trong hướng dẫn này, bạn có thể chọn Python 3

Có khả năng Mu không được cài đặt sẵn trên phiên bản Raspbian của bạn. Nếu Mu chưa được cài đặt, thì bạn luôn có thể cài đặt nó bằng cách đi tới vị trí tệp sau

Biểu tượng Raspberry Pi → Tùy chọn → Phần mềm được đề xuất

Thao tác này sẽ mở ra một hộp thoại chứa phần mềm được đề xuất cho Raspberry Pi của bạn. Chọn hộp bên cạnh Mu và nhấp vào OK để cài đặt nó

Mặc dù Mu cung cấp một trình chỉnh sửa tuyệt vời để bắt đầu với Python trên Raspberry Pi, nhưng bạn có thể muốn một thứ gì đó mạnh mẽ hơn. Trong phần tiếp theo, bạn sẽ kết nối với Raspberry Pi của mình qua SSH

Chỉnh sửa từ xa qua SSH

Thường thì bạn sẽ không muốn dành thời gian kết nối màn hình, bàn phím và chuột để viết Python trên Raspberry Pi. May mắn thay, Raspbian cho phép bạn kết nối với Raspberry Pi từ xa qua SSH. Trong phần này, bạn sẽ tìm hiểu cách bật và sử dụng SSH để lập trình Python trên Raspberry Pi

pi@raspberrypi:~ $ hostname -I

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $ python3

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Tạo thư mục

$ ssh pi@[IP ADDRESS]

9

Trước khi bạn bắt đầu xây dựng các dự án bằng Python trên Raspberry Pi, bạn nên thiết lập một thư mục dành riêng cho mã của mình. Raspberry Pi có một hệ thống tệp đầy đủ với nhiều thư mục khác nhau. Có một vị trí dành riêng cho mã Python của bạn sẽ giúp giữ mọi thứ ngăn nắp và dễ tìm

Hãy tạo một thư mục có tên là

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

Linh kiện điện tử

Trước khi lập trình trên Raspberry Pi, bạn sẽ cần một vài linh kiện điện tử để xây dựng các dự án trong các phần sắp tới. Bạn sẽ có thể tìm thấy từng mặt hàng bên dưới trên Amazon hoặc tại cửa hàng điện tử địa phương của bạn

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

Chân GPIO

Raspberry Pi có bốn mươi chân GPIO dọc theo cạnh trên của bo mạch. Bạn có thể sử dụng các chân GPIO này để kết nối Raspberry Pi với các thành phần bên ngoài

Bố cục ghim bên dưới hiển thị các loại ghim khác nhau và vị trí của chúng. Bố cục này dựa trên chế độ xem từ trên cao của các chân với các cổng USB của Raspberry Pi hướng về phía bạn

Raspberry Pi có năm loại chân khác nhau

1. GPIO. Đây là những chân có mục đích chung có thể được sử dụng cho đầu vào hoặc đầu ra
2. 3V3. Các chân này cung cấp 3. Nguồn điện 3 V cho linh kiện. 3. 3 V cũng là điện áp bên trong mà tất cả các chân GPIO cung cấp
3. 5V. Các chân này cung cấp nguồn điện 5 V, giống như đầu vào nguồn USB cấp nguồn cho Raspberry Pi. Một số thành phần, chẳng hạn như cảm biến chuyển động hồng ngoại thụ động, yêu cầu 5 V
4. GND. Các chân này cung cấp kết nối đất cho các mạch
5. ADV. Các chốt chuyên dụng này là nâng cao và không được đề cập trong hướng dẫn này

Trong phần tiếp theo, bạn sẽ sử dụng các loại ghim khác nhau này để thiết lập thành phần đầu tiên của mình, nút xúc giác

Nút xúc giác

Đối với mạch đầu tiên của bạn, bạn sẽ kết nối một nút xúc giác với Raspberry Pi. Nút xúc giác là một công tắc điện tử, khi được nhấn sẽ đóng mạch. Khi đóng mạch, Raspberry Pi sẽ đăng ký tín hiệu BẬT. Bạn có thể sử dụng tín hiệu BẬT này để kích hoạt các hành động khác nhau

Trong dự án này, bạn sẽ sử dụng nút xúc giác để chạy các hàm Python khác nhau dựa trên trạng thái của nút. Hãy bắt đầu bằng cách nối nút với Raspberry Pi

1. Kết nối dây nhảy từ nữ sang nam từ chân GND của Raspberry Pi với đường ray âm của bảng mạch
2. Đặt một nút xúc giác trên máng xối ở giữa breadboard
3. Kết nối dây nhảy đực-đực từ đường ray âm của bảng mạch khung với hàng nơi đặt chân dưới bên trái của nút
4. Kết nối dây nhảy từ nữ sang nam từ chân GPIO4 của Raspberry Pi với hàng bảng mạch nơi đặt chân dưới bên phải của nút

Bạn có thể xác nhận hệ thống dây điện của mình với sơ đồ bên dưới

Bây giờ bạn đã kết nối mạch của mình, hãy viết mã Python để đọc đầu vào từ nút

Ghi chú. Nếu bạn gặp khó khăn khi tìm một chân cụ thể, thì hãy đảm bảo tham khảo hình ảnh bố trí chân GPIO khi xây dựng mạch của bạn. Bạn cũng có thể mua một bảng đột phá để dễ dàng tạo breadboarding

Bên trong thư mục

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

Nếu bạn đang sử dụng Mu thì hãy tạo tệp theo các bước sau

1. Nhấp vào mục menu Mới
2. Nhấp vào để lưu
3. Điều hướng đến thư mục

   import subprocess
   
   process = subprocess.Popen['ls -l /usr',
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE,
                              shell=True
                              ]
   stdout, stderr = process.communicate[]
   print[stdout.decode['utf-8']]

   70
4. Lưu tệp dưới dạng

   import subprocess
   
   process = subprocess.Popen['ls -l /usr',
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE,
                              shell=True
                              ]
   stdout, stderr = process.communicate[]
   print[stdout.decode['utf-8']]

   49

Với tệp được tạo, bạn đã sẵn sàng để bắt đầu mã hóa. Bắt đầu bằng cách nhập lớp

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

Tạo một thể hiện của lớp

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

Tiếp theo, xác định các chức năng sẽ được gọi cho các sự kiện nút khác nhau có sẵn trên phiên bản

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

Lớp

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

Mặc dù thuộc tính

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

Thời gian giữ cho

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
while process.poll[] is None:
    line = process.stdout.readline[]
    print['']

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

Thao tác này sẽ tạo một phiên bản

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

Bây giờ bạn đã biết về các thuộc tính sự kiện khác nhau trên

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

Tuyệt quá. Bạn đã thiết lập các sự kiện nút của mình. Điều cuối cùng bạn cần làm là gọi

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Chương trình cuối cùng của bạn sẽ trông như thế này

$ ssh pi@[IP ADDRESS]

Khi đã hoàn tất việc đi dây và thiết lập mã, bạn đã sẵn sàng để thử mạch đầu tiên của mình. Bên trong thư mục

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Nếu bạn đang sử dụng My, trước tiên hãy đảm bảo rằng tệp đã được lưu, sau đó nhấp vào Chạy để bắt đầu chương trình

Chương trình hiện đang chạy và lắng nghe các sự kiện. Nhấn nút và bạn sẽ thấy thông tin sau trong bảng điều khiển

$ ssh pi@[IP ADDRESS]

Nhấn và giữ nút trong ít nhất một giây và bạn sẽ thấy đầu ra sau

pi@raspberrypi:~ $

Cuối cùng, khi bạn nhả nút, bạn sẽ thấy như sau

pi@raspberrypi:~ $

Đáng kinh ngạc. Bạn vừa kết nối và mã hóa mạch đầu tiên của mình bằng Python trên Raspberry Pi

Vì bạn đã sử dụng

$ ssh pi@[IP ADDRESS]

Với mạch đầu tiên này, bạn đã sẵn sàng bắt đầu điều khiển một số thành phần khác

DẪN ĐẾN

Đối với mạch tiếp theo, bạn sẽ sử dụng Python để bật và tắt đèn LED nhấp nháy mỗi giây. LED là viết tắt của đi-ốt phát quang và các thành phần này tạo ra ánh sáng khi có dòng điện chạy qua. Bạn sẽ thấy rằng chúng được sử dụng ở mọi nơi trong ngành điện tử

Mỗi đèn LED có hai chân. Chân dài hơn là chân dương hoặc cực dương. Dòng điện đi vào LED thông qua chân này. Chân ngắn hơn là chân âm hoặc cực âm. Dòng ra khỏi LED qua chân này

Dòng điện chỉ có thể chạy theo một hướng qua đèn LED, vì vậy hãy đảm bảo rằng bạn đang kết nối dây nhảy với chân thích hợp của đèn LED

Dưới đây là các bước bạn cần thực hiện để nối dây mạch này

1. Kết nối dây nhảy từ nữ sang nam từ chân GND của Raspberry Pi với đường ray âm của bảng mạch

2. Đặt một đèn LED vào hai lỗ trên breadboard cạnh nhau nhưng không cùng hàng

3. Đặt chân dương, dài hơn của đèn LED vào lỗ ở bên phải

4. Đặt chân âm, ngắn hơn của đèn LED vào lỗ ở bên trái

5. Đặt một đầu của điện trở 330 Ω vào một lỗ trên cùng một hàng của breadboard với chân âm của đèn LED

6. Đặt đầu kia của điện trở vào đường ray âm của breadboard

7. Kết nối dây nhảy từ nữ sang nam từ chân GPIO4 của Raspberry Pi với một lỗ trên cùng hàng bảng mạch với chân dương của đèn LED

Bạn có thể xác nhận hệ thống dây điện của mình với sơ đồ bên dưới

Nếu hệ thống dây điện có vẻ tốt, thì bạn đã sẵn sàng viết một số Python để đèn LED nhấp nháy. Bắt đầu bằng cách tạo một tệp cho mạch này bên trong thư mục

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $

Trong mã này, bạn sẽ tạo một thể hiện của lớp

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Bắt đầu bằng cách nhập

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

pi@raspberrypi:~ $

Tiếp theo, tạo một thể hiện của

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

pi@raspberrypi:~ $

Gọi phương thức

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $

Cuối cùng, thêm lệnh gọi tới

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $

Chương trình hoàn chỉnh của bạn sẽ trông như thế này

pi@raspberrypi:~ $

Lưu tệp và chạy nó để xem đèn LED nhấp nháy và tắt

pi@raspberrypi:~ $

Đèn LED hiện sẽ nhấp nháy và tắt mỗi giây. Khi bạn đã hoàn tất việc chiêm ngưỡng mã Python của mình đang hoạt động, hãy dừng chương trình bằng Ctrl + C or Stop in Mu.

Bây giờ bạn đã biết cách điều khiển đèn LED bằng Python trên Raspberry Pi. Đối với mạch tiếp theo, bạn sẽ sử dụng Python để tạo âm thanh từ Raspberry Pi

còi

Trong mạch này, bạn sẽ nối một bộ rung áp điện đang hoạt động với Raspberry Pi. Bộ rung áp điện phát ra âm báo khi có dòng điện chạy qua. Sử dụng thành phần này, Raspberry Pi của bạn sẽ có thể tạo ra âm thanh

Giống như đèn LED, còi có chân dương và chân âm. Chân dương của bộ rung hoặc sẽ dài hơn chân âm hoặc sẽ có một dấu hiệu dương [

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

Hãy tiếp tục và nối dây cho còi

1. Đặt bộ rung trên breadboard, lưu ý vị trí của chân dương của bộ rung

2. Kết nối dây nhảy từ nữ sang nam từ chân GND của Raspberry Pi với một lỗ trên cùng hàng bảng mạch với chân âm của bộ rung

3. Kết nối dây nhảy từ nữ sang nam từ chân GPIO4 của Raspberry Pi với một lỗ trên cùng hàng bảng mạch với chân dương của bộ rung

Xác nhận hệ thống dây điện của bạn dựa trên sơ đồ bên dưới

Với hệ thống dây điện được thiết lập, hãy chuyển sang mã. Tạo một tệp cho mạch này bên trong thư mục

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $

Trong mã này, bạn sẽ tạo một thể hiện của lớp

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Bắt đầu bằng cách nhập

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

pi@raspberrypi:~ $ python3

Tiếp theo, tạo một thể hiện của

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

pi@raspberrypi:~ $ python3

Gọi phương thức

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $ python3

Cuối cùng, thêm lệnh gọi tới

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $

Chương trình hoàn chỉnh của bạn sẽ trông như thế này

pi@raspberrypi:~ $ python3

Save the file and run it to hear the buzzer beep on and off every half second

pi@raspberrypi:~ $ python3

You should hear the buzzer sound on and off until you stop the program with Ctrl + C or Stop in Mu.

Note. If you’re using Mu, then there’s a chance that when you stop the program the tone will continue. To stop the sound, remove the GND wire to break the circuit

You may also need to restart Mu if the tone continues when you reconnect the GND wire

Great. So far you’ve learned how to control three different types of electronic components with Python on the Raspberry Pi. For the next circuit, let’s take a look at a slightly more complex component

Motion Sensor

In this circuit, you’ll be connecting a passive infrared [PIR] motion sensor to the Raspberry Pi. A passive infrared motion sensor detects any motion in its field of vision and sends a signal back to the Raspberry Pi

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $ python3

$ ssh pi@[IP ADDRESS]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $ python3

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $ python3

$ ssh pi@[IP ADDRESS]

pi@raspberrypi:~ $ python3

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Wiring

Here are the steps to complete the wiring

1. Connect female-to-male jumper wires from the Raspberry Pi’s 5V and GND pins to the positive and negative rails on the side of the breadboard

2. Đặt một đèn LED trên breadboard và kết nối chân GPIO14 của Raspberry Pi với đèn LED bằng dây nhảy từ nữ sang nam

3. Nối chân âm của đèn LED với chân âm của breadboard thông qua điện trở 330 Ω

4. Đặt một bộ rung trên breadboard và kết nối chân GPIO15 của Raspberry Pi với bộ rung bằng dây nhảy từ nữ sang nam

5. Kết nối chân âm của bộ rung với thanh âm của bảng mạch bánh mì bằng dây nhảy đực-đực

6. Kết nối dây nhảy từ đầu cái sang đầu đực từ đường ray dương của bảng mạch khung với chân VCC của cảm biến

7. Connect a female-to-female jumper wire from the Raspberry Pi’s GPIO4 pin to the sensor’s OUT pin

8. Kết nối dây nhảy từ đầu cái sang đầu đực từ đường ray âm của bảng mạch với chân GND của cảm biến

Xác nhận nối dây theo sơ đồ bên dưới

Được rồi, bây giờ bạn đã kết nối mạch, hãy tìm hiểu mã Python để thiết lập hệ thống báo động kích hoạt chuyển động của bạn

Mã số

Như thường lệ, hãy bắt đầu bằng cách tạo một tệp cho dự án này bên trong thư mục

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Điều đầu tiên bạn muốn làm là nhập mô-đun

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Tiếp theo, nhập

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Cuối cùng, nhập các lớp thành phần bắt buộc từ

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import subprocess

process = subprocess.Popen['ls -l /usr',
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           shell=True
                           ]
stdout, stderr = process.communicate[]
print[stdout.decode['utf-8']]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Khi đã sẵn sàng nhập, bạn có thể thiết lập ba thành phần điện tử mà bạn sẽ sử dụng. Tạo các thể hiện của các lớp

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Tiếp theo, xác định vị trí của tệp CSV sẽ lưu trữ dấu thời gian mỗi khi phát hiện chuyển động. Bạn sẽ gọi nó là

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Tạo phương thức lưu dữ liệu dấu thời gian vào tệp CSV. Khi tệp được tạo lần đầu tiên, một hàng tiêu đề sẽ được thêm vào

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Xác định hàm

$ ssh pi@[IP ADDRESS]

• Bắt đầu nhấp nháy bật và tắt

  $ ssh pi@[IP ADDRESS]
  

  21 cứ sau nửa giây
• Tạo tiếng bíp

  $ ssh pi@[IP ADDRESS]
  

  40
• Lưu dấu thời gian

  $ ssh pi@[IP ADDRESS]
  

  84 vào từ điển

  $ ssh pi@[IP ADDRESS]
  

  85

Thêm lệnh gọi tới

$ ssh pi@[IP ADDRESS]

import os
stream = os.popen['cat /etc/services']
output = stream.read[]
print[output]

Sau đó, xác định hàm

$ ssh pi@[IP ADDRESS]

• Tắt

  $ ssh pi@[IP ADDRESS]
  

  21 và

  $ ssh pi@[IP ADDRESS]
  

  40
• Lưu dấu thời gian

  $ ssh pi@[IP ADDRESS]
  

  90
• Gọi

  $ ssh pi@[IP ADDRESS]
  

  91 để lưu dữ liệu chuyển động vào tệp CSV
• Đặt lại từ điển

  $ ssh pi@[IP ADDRESS]
  

  85

Bạn cũng sẽ kiểm tra xem có tồn tại giá trị

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Thêm lệnh gọi tới

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Đặt thuộc tính

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Cuối cùng, kết thúc mã bằng lệnh gọi tới

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Lưu tệp và chạy nó để kiểm tra cảnh báo phát hiện chuyển động mới của bạn

$ ssh pi@[IP ADDRESS]

Bây giờ nếu bạn vẫy tay trước bộ phát hiện chuyển động, thì tiếng còi sẽ bắt đầu phát ra tiếng bíp và đèn LED sẽ nhấp nháy. Nếu bạn dừng di chuyển trong vài giây, thì báo thức sẽ dừng. Trong bảng điều khiển, bạn sẽ thấy như sau

$ ssh pi@[IP ADDRESS]

Hãy tiếp tục và dừng chương trình bằng Stop in Mu hoặc Ctrl + C. Let’s check out the CSV file that was generated:

$ ssh pi@[IP ADDRESS]

Như bạn có thể thấy, dấu thời gian cho chuyển động

$ ssh pi@[IP ADDRESS]

$ ssh pi@[IP ADDRESS]

Xin chúc mừng. Bạn đã tạo một dự án điện tử không tầm thường với Python trên Raspberry Pi

Bước tiếp theo

Bạn không cần phải dừng lại ở đây. Có nhiều cách bạn có thể cải thiện dự án này bằng cách tận dụng khả năng của Python trên Raspberry Pi

Dưới đây là một số cách để tăng cấp dự án này

• Kết nối Mô-đun máy ảnh Raspberry Pi và chụp ảnh bất cứ khi nào phát hiện chuyển động

• Kết nối loa với Raspberry Pi và sử dụng PyGame để phát tệp âm thanh nhằm đe dọa kẻ xâm nhập

• Thêm một nút vào mạch để cho phép người dùng bật hoặc tắt tính năng phát hiện chuyển động theo cách thủ công

Có nhiều cách để nâng cấp dự án này. Hãy cho chúng tôi biết những gì bạn nghĩ ra