Trong hướng dẫn này, chúng ta học cách lập trình Arduino cơ bản thông qua các mã ví dụ và chương trình mẫu. Hướng dẫn này có thể là một khóa học cực kỳ có giá trị cho tất cả những người mới muốn nắm bắt những kiến thức cơ bản thông qua ngôn ngữ dễ hiểu, dễ hiểu.

Giới thiệu

Dựa theo wikipedia một bộ vi điều khiển tương đương với một máy tính mini được xây dựng bên trong một chip IC đơn, có bộ xử lý lõi riêng, đầu vào có thể lập trình, bộ nhớ và thiết bị ngoại vi đầu ra.

Một bộ vi điều khiển trở nên rất hữu ích cho người dùng vì nó cung cấp một bộ xử lý tích hợp, bộ nhớ và các cổng đầu vào / đầu ra (còn được gọi là GPIO hoặc các chân đầu vào / đầu ra mục đích chung) mà người dùng có thể kiểm soát chúng theo bất kỳ thông số kỹ thuật mong muốn nào.

“mã màu điện trở phim kim loại ”

Trong hướng dẫn này, chúng tôi sẽ làm việc với bảng Arduino Uno để học và thử nghiệm các chương trình. Để kiểm tra và tích hợp lắp ráp phần cứng, chúng tôi sẽ sử dụng một breadboard.

Bây giờ hãy nhanh chóng di chuyển và tìm hiểu cách bắt đầu với lập trình Arduino.

1.2 Cài đặt phần mềm (Windows)

Đối với điều này, bạn sẽ cần truy cập internet, mà rõ ràng bạn sẽ có trong máy tính của mình. Vui lòng truy cập vào liên kết sau và tải phần mềm IDE:

Tệp ZIP Windows cho cài đặt không phải quản trị viên

Sau khi tải xuống, bạn sẽ tìm thấy biểu tượng thiết lập Arduino trong thư mục tải xuống, trông giống như sau:

Khi bạn nhận được điều này, bạn chỉ cần nhấp đúp vào nó và cài đặt Arduino Môi trường phát triển tích hợp (IDE) vào máy tính của bạn. Quá trình hoàn chỉnh có thể được hình dung trong video sau:

https://youtu.be/x7AMn1paCeU

1.4 Bắt đầu với mạch đầu tiên của chúng tôi

Trước khi chúng ta bắt đầu học các kỹ thuật lập trình thực tế, đối với bất kỳ người mới nào, sẽ hữu ích khi bắt đầu với một thành phần cơ bản như đèn LED và hiểu cách kết nối nó với Arduino.

Như chúng ta đã biết, đèn LED là một điốt phát sáng có cực tính và sẽ không phát sáng nếu nó không được kết nối với các cực cung cấp phù hợp.

Một khía cạnh khác với đèn LED là các thiết bị này hoạt động với dòng điện thấp và có thể bị hỏng ngay lập tức nếu một điện trở được tính toán thích hợp không được mắc nối tiếp với một trong các chân của nó.

Theo quy tắc chung, 330 ohm 1/4 watt là khá lý tưởng cho mỗi mức tăng 5V trong đầu vào nguồn cung cấp để giới hạn dòng điện đến mức an toàn cần thiết. Do đó đối với 5V nó có thể là 330 ohms, đối với 10V nó có thể là 680 ohms, v.v.

Sử dụng Breadboard cho Assembly

Hãy đảm bảo rằng bạn biết cách sử dụng breadboard trước khi thử hướng dẫn được giải thích trong chương này, vì chúng tôi sẽ sử dụng breadboard cho tất cả các thử nghiệm ở đây.

Thiết lập kết nối LED cơ bản có thể được chứng kiến dưới đây:

Bạn có thể thấy 3 thành phần cơ bản ở trên:

Đèn LED 5mm, 20mA
một điện trở 330 ohm 1/4 watt
An Bảng Arduino

Chỉ cần lắp ráp hệ thống theo sơ đồ.

Tiếp theo, cắm 5V từ USB máy tính vào Arduino. Ngay sau khi bạn làm điều này, bạn sẽ thấy đèn LED sáng lên.

Tôi biết điều đó khá cơ bản, nhưng sẽ luôn tốt nếu bắt đầu lại từ đầu. Hãy yên tâm rằng mọi thứ sẽ bắt đầu ngày càng thú vị hơn khi chúng ta tiến lên phía trước.

1.5 Điều khiển đèn LED với Arduino

Bây giờ chúng ta sẽ tìm hiểu cách điều khiển đèn LED bằng chương trình Arduino.

Để viết chương trình chúng ta phải có ít nhất 2 hàm trong mỗi chương trình.

Một hàm có thể được hiểu là một chuỗi các câu lệnh lập trình có thể được gán với một tên, như dưới đây:

thiết lập() điều này được gọi hoặc thực thi trong khi bắt đầu chương trình.
vòng() điều này được gọi hoặc thực hiện lặp đi lặp lại trong toàn bộ thời gian hoạt động của Arduino.

Do đó, mặc dù nó có thể không có chức năng thực tế, về mặt kỹ thuật, một chương trình Arduino hợp pháp ngắn nhất có thể được viết như sau:

Chương trình đơn giản nhất

void setup() { } void loop() { }

Bạn có thể nhận thấy rằng trong nhiều ngôn ngữ lập trình, hệ thống bắt đầu bằng cách hiển thị một chữ in đơn giản, 'Xin chào, Thế giới' trên màn hình hiển thị

Tương đương điện tử cho cụm từ này trong cách diễn giải vi điều khiển là nhấp nháy đèn LED BẬT và TẮT.

Đây là chương trình cơ bản nhất mà người ta có thể viết và triển khai để chỉ ra một hệ thống hoạt động chính xác.

Chúng tôi sẽ cố gắng triển khai và hiểu quy trình thông qua đoạn mã sau:

Liệt kê 1.2: led1 / led1.pde

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

OK, bây giờ chúng ta hãy hiểu ý nghĩa của từng dòng mã và cách nó hoạt động để thực thi hàm:

const int kPinLed = 13

Điều này hoạt động giống như một hằng số cho phép chúng ta sử dụng nó trong suốt quá trình lập trình hoàn chỉnh, mà không cần sử dụng giá trị thực tế được đặt chống lại nó.

Theo các quy tắc tiêu chuẩn, các hằng số như vậy được công nhận bằng chữ cái bắt đầu đến . Mặc dù điều này không bắt buộc, nhưng nó làm cho mọi thứ trở nên rõ ràng và dễ hiểu bất cứ khi nào bạn muốn xem qua các chi tiết mã.

void setup() { pinMode(kPinLed, OUTPUT) }

Mã này định cấu hình chân cụ thể mà đèn LED của chúng tôi được nối vào. Nói cách khác, mã lệnh cho Arduino kiểm soát khía cạnh 'ghi' trên chân này, thay vì 'đọc' nó.

void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

Các dòng trên cho biết quá trình thực thi thực tế của ứng dụng. Mã bắt đầu bằng cách viết và hiển thị CAO trên kết nối LED có liên quan, BẬT LED.

Ở đây, thuật ngữ HIGH đơn giản có nghĩa là nhận + 5V trên chân liên quan của Arduino. Thuật ngữ bổ sung LOW chỉ đơn giản là chỉ số 0 hoặc 0V trên chân được chỉ định.

Tiếp theo, chúng tôi gọi delay() có chức năng là tạo độ trễ qua mili giây (1/1000 giây). Vì hình 500 được nhập, độ trễ được triển khai sẽ là 1/2 giây.

Ngay sau khi 1/2 giây này trôi qua, dòng tiếp theo sẽ được thực hiện, dòng tiếp theo sẽ TẮT LED với thuật ngữ THẤP trên cùng một chân.

Dòng tiếp theo lại tạo ra độ trễ 1/2 giây, để cho phép đèn LED ở trạng thái TẮT trong 1/2 giây.

Và quá trình này tiếp tục vô tận bằng cách thực thi các dòng mã, miễn là Arduino được duy trì nguồn điện.

Trước khi chuyển sang cấp độ tiếp theo, tôi khuyên bạn vui lòng lập trình đoạn mã trên và kiểm tra xem bạn có thể triển khai trình tự BẬT / CỦA LED một cách chính xác hay không.

Vì đèn LED mặc định trong Arduino được kết nối với chân số 13, nó sẽ phản hồi ngay lập tức với chương trình trên và bắt đầu nhấp nháy. Tuy nhiên, nếu bạn thấy đèn LED bên ngoài của mình không nhấp nháy thì có thể có lỗi kết nối với đèn LED của bạn, bạn có thể thử đảo ngược cực của đèn LED và hy vọng nó cũng nhấp nháy.

Bạn có thể chơi với thời gian trễ bằng cách thay đổi con số '500' thành một số giá trị khác và tìm đèn LED 'lắng nghe' các lệnh và làm cho nó nhấp nháy theo các giá trị độ trễ được chỉ định.

Nhưng hãy nhớ rằng, nếu bạn thấy đèn LED không nhấp nháy với tốc độ 1 giây không đổi, bất kể sự thay đổi thời gian trễ của bạn, điều đó có thể cho thấy mã không hoạt động do một số lỗi. Vì mặc định Arduino sẽ được lập trình với tốc độ nhấp nháy 1 giây. Do đó, tỷ lệ này phải thay đổi theo mã của bạn để xác nhận nó hoạt động chính xác.

1.7 Bình luận

Các dòng mã mà chúng ta đã hiểu ở trên được viết riêng cho phần mềm máy tính.

Tuy nhiên, để đảm bảo rằng người dùng có thể tham khảo ý nghĩa của các dòng và hiểu chúng, thường có thể hữu ích và hợp lý khi viết giải thích bên cạnh các dòng mã mong muốn.

Chúng được gọi là bình luận được viết chỉ để con người hoặc người dùng tham khảo và được mã hóa để cho phép máy tính bỏ qua nó một cách an toàn.

Ngôn ngữ của những nhận xét này được viết với một số định dạng:

Kiểu khối của nhận xét, trong đó mô tả nhận xét được bao gồm dưới ký hiệu bắt đầu / * và ký hiệu kết thúc * /
Điều này không phải giới hạn trong một dòng mà có thể được mở rộng sang các dòng tiếp theo tiếp theo tùy thuộc vào độ dài của nhận xét hoặc mô tả, như được hiển thị trong ví dụ sau:

/ * Đây là một nhận xét * /

/ * Đây cũng vậy * /

/ * Và
* điều này
* như
* tốt */

Để viết mô tả một dòng nhanh chóng cho một nhận xét, hai dấu gạch chéo // ở đầu là đủ. Điều này cho máy tính biết rằng dòng này không liên quan gì đến mã thực và phải được bỏ qua. Ví dụ:

// Đây là nhận xét mà máy tính sẽ bỏ qua.

Đây là một ví dụ để tham khảo:

/* * Program Name: Blink * Author: Alan Smith * Description: * Turns an LED on for one half second, then off for one half second repeatedly. */

/* Pin Definitions */ const int kPinLed = 13 /* * Function Name: setup * Purpose: Run once when the system powers up. */ void setup() { pinMode(kPinLed, OUTPUT) } /* * Function name: loop * Purpose: Runs over and over again, as long as the Arduino has power */ void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

1.8 Khắc phục sự cố

Nếu bạn thấy chương trình của mình hiển thị 'lỗi' trong khi biên dịch hoặc một số vấn đề khác, các mẹo sau có thể sẽ giúp bạn kiểm tra lại mã của mình để thoát khỏi trở ngại.

Ngôn ngữ chương trình của bạn sẽ phân biệt chữ hoa chữ thường. Ví dụ biểu thức myVar không thể được viết là MyVar.
Tất cả các loại khoảng trắng có thể được thực thi bằng cách gõ bàn phím của bạn, cuối cùng được hiển thị dưới dạng một khoảng trắng và chỉ bạn mới nhìn thấy hoặc hiểu được, máy tính sẽ không tính đến điều này. Nói một cách đơn giản, không gian trống dưới bất kỳ hình thức nào sẽ không có bất kỳ ảnh hưởng nào đến kết quả mã.
Mỗi khối mã phải được đặt trong dấu ngoặc nhọn trái và phải, '{' và '}'
Các chữ số không được phân tách bằng dấu phẩy. Ví dụ: 1000 có thể không được viết là 1.000.
Mọi dòng mã nằm giữa dấu ngoặc nhọn phải kết thúc bằng dấu chấm phẩy

Tạo chuỗi ánh sáng LED thú vị với Arduino

Trong chương trước, chúng ta đã học cách nhấp nháy đèn LED BẬT / TẮT liên tục với tốc độ trễ không đổi.

Bây giờ chúng ta sẽ tìm hiểu cách các mẫu độ trễ khác nhau có thể được thực thi trên cùng một đèn LED bằng cách nâng cấp mã chương trình.

Chúng tôi sẽ không sử dụng đèn LED bên ngoài, thay vì sử dụng đèn LED mặc định được tích hợp trong bảng Arduino ở chân # 13. Bạn có thể tìm thấy đèn LED SMD nhỏ này ngay sau đầu nối USB.

2.2 Hiểu các câu lệnh IF

Trong phần này, chúng ta sẽ tìm hiểu cách các cấu trúc điều khiển cho phép chúng ta chạy các mã riêng lẻ và đôi khi thậm chí lặp đi lặp lại theo yêu cầu.

Tuyên bố nếu trở thành cấu trúc điều khiển thứ nhất. Việc triển khai sau đây cho thấy cách nó được sử dụng:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { delayTime = delayTime - 100 if(delayTime <= 0){ // If the delay time is zero or less, reset it. delayTime = 1000 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

Chúng tôi sẽ cố gắng hiểu từng bước mã ở trên và tìm hiểu cách điều này có thể được sử dụng cho các lần thực thi tương tự khác.

Các mã giữa dòng 1 và dòng 7 hoàn toàn giống với chương trình ban đầu của chúng tôi.

Sửa đổi đầu tiên thực sự xảy ra trên dòng thứ 8.

int delayTime = 1000

Bạn có thể thấy mã này giống với mã trên dòng đầu tiên, ngoại trừ thực tế là nó bị thiếu cụm từ hăng sô.

Điều này đơn giản là bởi vì, mã này không phải là một hằng số. Thay vào đó, điều này được định nghĩa là Biến đổi , có thuộc tính của một giá trị thay đổi trong quá trình lập trình.

Trong ví dụ trên, bạn có thể thấy rằng biến này được quy với giá trị là 1000. Hãy nhớ rằng, các biến như vậy nằm trong dấu ngoặc nhọn chỉ được viết đúng trong cặp dấu ngoặc nhọn và được gọi là biến 'cục bộ'.

Ngoài ra, các biến được cho là nằm ngoài dấu ngoặc nhọn, như biến mà chúng ta đang thảo luận bây giờ được công nhận là 'toàn cục' và có thể được thực thi ở bất cứ đâu trong mã chương trình.

Tiếp tục, bạn có thể thấy rằng các mã giữa dòng 9 và 11 cũng tương tự như chương trình đầu tiên, nhưng mọi thứ bắt đầu trở nên thú vị sau dòng 11. Hãy xem làm thế nào!

delayTime = delayTime - 100

Trong đoạn mã này, chúng tôi thấy rằng giá trị mặc định của thời gian trì hoãn đang được sửa đổi bằng cách lấy nó trừ đi 100.

Có nghĩa là 100 được khấu trừ từ giá trị ban đầu của nó là 1000, cung cấp cho nó một giá trị mới là 900.

Qua hình ảnh sau đây, chúng ta sẽ cố gắng hiểu một vài toán tử Toán học được sử dụng trong ngôn ngữ Arduino.

Bây giờ hãy đánh giá các mã giữa dòng 13 và dòng 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it. delayTime = 1000 }

Mục tiêu chính của đoạn mã trên là đảm bảo rằng đèn LED tiếp tục nhấp nháy mà không bị gián đoạn.

Vì thực tế là 100 đang được khấu trừ từ ban đầu thời gian trì hoãn , nó ngăn không cho đèn LED nhấp nháy về 0 và cho phép nhấp nháy liên tục.

Hình ảnh sau đây cho thấy một số toán tử so sánh mà chúng tôi sẽ sử dụng trong mã của mình:

Trong đoạn mã trên, chúng tôi có thể đã kiểm tra mã là if(delayTime == 0).

Tuy nhiên, vì con số tiêu cực cũng có thể tồi tệ như nhau, chúng tôi đã không thực hiện nó, và đây là một thực hành được khuyến khích.

Hãy nghĩ xem kết quả có thể ra sao nếu chúng ta cố gắng trừ đi 300 thay vì 100 từ delayTime?

Vì vậy, bây giờ bạn có thể đã nhận ra rằng nếu delayTime được viết dưới dạng nhỏ hơn hoặc bằng 0, khi đó thời gian trễ sẽ được đặt trở lại hình 1000 ban đầu.

digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime)

4 dòng cuối cùng của mã như hình trên có nhiệm vụ bật / tắt đèn LED, BẬT / TẮT liên tục.

Ở đây bạn có thể nhận thấy rõ ràng rằng thay vì sử dụng một số hình, chúng tôi đã sử dụng một biến để ấn định thời gian trễ để chúng tôi có thể điều chỉnh nó theo ý muốn trong suốt thời gian hoạt động của mã. Thật tuyệt, phải không?

2.3 Câu lệnh ELSE

Ở đây chúng ta sẽ tìm hiểu tại sao và làm thế nào nếu thuật ngữ có thể có một điều khoản khác để nó quyết định tình huống trong trường hợp nếu tuyên bố là sai.

Tôi xin lỗi nếu điều đó nghe có vẻ quá khó hiểu, đừng lo lắng, chúng tôi sẽ cố gắng hiểu nó bằng ví dụ sau:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { if(delayTime <= 100){ // If it is less than or equal to 100, reset it delayTime = 1000 } else{ delayTime = delayTime - 100 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

Ở trên, bạn có thể thấy rằng trong dòng thứ 10, mã chỉ được thực thi khi dấu delayTime nhỏ hơn hoặc bằng 100, nếu không thì mã ở dòng thứ 13 sẽ được thực thi, nhưng cả hai cùng nhau không bao giờ có thể xảy ra, hoặc dòng thứ 10 hoặc mã dòng thứ 13 sẽ được thực hiện, không bao giờ cả hai.

Bạn có thể nhận thấy rằng không giống như những gì chúng tôi đã làm trong phần 2.2 trước đó của chúng tôi, ở đây chúng tôi không so sánh với 0, thay vì so sánh với 100. Điều này là do trong ví dụ này so sánh TRƯỚC KHI chúng tôi trừ đi 100, ngược lại trong phần 2.2, chúng tôi so sánh SAU KHI chúng tôi bị trừ. Bạn có thể cho biết điều gì có thể xảy ra nếu chúng ta so sánh 0 thay vì 100 không?

2.4 Câu lệnh WHILE

ĐẾN trong khi tuyên bố khá giống với nếu , ngoại trừ sự thật là nó gây ra thực thi lặp lại một khối mã (có thể nằm giữa dấu ngoặc nhọn) trong thời gian dài các điều kiện có thể áp dụng và điều này hoạt động mà không cần khác tuyên bố.

Ví dụ sau sẽ giúp bạn hiểu rõ hơn về điều này

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { while(delayTime > 0){ // while delayTime is greater than 0 digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) delayTime = delayTime - 100 } while(delayTime <1000){ // while delayTime is less than 1000 delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0 digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) } }

Bạn có đoán được đoạn mã trên được lập trình để làm gì không? Vâng, nó được thiết kế để nhấp nháy đèn LED nhanh hơn và sau đó chậm hơn.

2.5 Đúng và sai là gì?

Trong ngôn ngữ lập trình, sai đề cập đến số không (0). Trên thực tế, 'true' không được sử dụng, thay vào đó nó được giả định rằng khi không có gì là sai, thì tất cả những gì được bao gồm là đúng.

Nó trông hơi lạ nhưng nó thực hiện công việc khá tốt.

Chúng tôi sẽ cố gắng nắm bắt tình hình thông qua ví dụ sau.

Đôi khi bạn có thể gặp một mã như dưới đây:

while (1){ digitalWrite(kPinLed, HIGH) delay(100) digitalWrite(kPinLed, LOW) delay(100) }

Điều này được mã hóa có vẻ như việc thực thi đèn LED sẽ tiếp tục quay vòng mãi mãi, miễn là có sẵn nguồn điện.

Tuy nhiên, một nhược điểm của loại mã này có thể phát sinh khi người dùng vô tình áp dụng = thay vì ==.

Tôi chắc rằng bạn đã biết rằng = biểu thị một phép gán, nghĩa là nó được sử dụng để chỉ định một giá trị đã chọn cho một biến, trong khi dấu == được sử dụng để thực thi kiểm tra nếu giá trị giống nhau.

Ví dụ: giả sử bạn yêu cầu đèn LED nhấp nháy với kiểu tăng tốc tuần tự và lặp lại, nhưng đã sử dụng sai dấu = thay vì ==.

Sau đó, mã sẽ xuất hiện như sau:

int delayTime = 1000 void loop() { if(delayTime = 0){ // WRONG!!! the = should have been == delayTime = 1000 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) delayTime = delayTime - 100 }

Sai lầm sẽ gán 0 cho delayTime, và dẫn đến nếu để kiểm tra xem 0 có đúng hay không. Vì 0 đề cập đến sai, nó sẽ nghĩ nó không đúng và sẽ ngừng thực thi delayTime = 1000, mà thay vào đó là hàm delayTime được giữ ở 0 trong suốt quá trình của vòng lặp ().

Điều này trông rất không mong muốn !!

Vì vậy, hãy luôn kiểm tra lại chương trình của bạn để đảm bảo rằng bạn không mắc phải bất kỳ lỗi ngớ ngẩn nào như vậy.

2.6 Kết hợp

Đôi khi bạn có thể cảm thấy cần phải thử nghiệm nhiều thứ cùng nhau. Giống như, bạn có thể muốn kiểm tra xem một biến có nằm giữa hai số hay không. Mặc dù điều này có thể được thực hiện bằng cách sử dụng câu lệnh if nhiều lần, nhưng có thể thuận tiện hơn khi sử dụng các tổ hợp logic để đọc tốt hơn và dễ dàng hơn.

Việc triển khai kết hợp trên các thuật ngữ logic có thể được thực hiện bằng 3 phương pháp, như được hiển thị trong bảng sau:

bảng hiển thị các phương pháp kết hợp Arduino

Sẽ rất thú vị khi biết rằng toán tử NOT có thể hoạt động như một bộ chuyển đổi cho một biến có thể được chỉ định là thật hoặc là sai (hoặc THẤP hoặc CAO).

Ví dụ sau minh họa điều kiện:

int ledState = LOW void loop() { ledState = !ledState // toggle value of ledState digitalWrite(kPinLed, ledState) delay(1000) }

Đây là ledState sẽ ở mức THẤP, và sau đó ngay sau khi ledState = !ledState, nó sẽ chuyển sang CAO. Vòng lặp sau sẽ gây ra ledState CAO khi ledState = !ledState chậm.

2.7 Câu lệnh FOR

Bây giờ chúng ta sẽ cố gắng hiểu về một cấu trúc điều khiển khác là cho vòng. Điều này có thể rất hữu ích khi bạn muốn thực hiện một số lần.

Hãy hiểu điều này với ví dụ sau:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { for(int i = 0 i <4 i++){ digitalWrite(kPinLed, HIGH) delay(200) digitalWrite(kPinLed, LOW) delay(200) } delay(1000) // 1 second }

Bạn có thể tìm thấy thứ gì đó độc đáo trong dòng cho.

Nó là mã i ++? . Điều này hữu ích cho các lập trình viên khá lười biếng và muốn thực hiện mã hóa thông qua các phím tắt thuận tiện

Thuật ngữ trên được gọi là toán tử ghép, vì chúng thực hiện công việc kết hợp một toán tử gán với một toán tử gán khác. Phổ biến nhất trong số này có thể được hình dung trong bảng sau:

Bạn sẽ thấy rằng có 3 câu lệnh con trong một câu lệnh for. Nó có cấu trúc như hình dưới đây:

for (statement1conditionstatement2){ // statements }

Câu lệnh số 1 xảy ra ngay ở phần đầu và chỉ một lần. Điều kiện được kiểm tra mỗi lần trong suốt quá trình của vòng lặp. Bất cứ khi nào nó là thật bên trong dấu ngoặc nhọn, câu lệnh số 2 tiếp theo được thực thi. Trong trường hợp của một sai, hệ thống sẽ chuyển đến khối mã tiếp theo.

Kết nối thêm đèn LED

OK, bây giờ chúng ta sẽ xem cách chúng ta có thể kết nối nhiều LEds hơn để nhận được nhiều hiệu ứng thú vị hơn.

Vui lòng kết nối đèn LED và Arduino như hình dưới đây. Dây màu đỏ thực sự không cần thiết, nhưng vì luôn luôn là một ý tưởng hay khi có cả hai đường ray cung cấp vào bảng mạch nên việc thiết lập sẽ có ý nghĩa.

Bây giờ chúng ta hãy sửa một chương trình cho phép chúng ta kiểm tra xem phần cứng của chúng ta có được cấu hình đúng hay không.

Bạn nên viết mã và thực thi các đoạn chương trình nhỏ theo từng bước khôn ngoan để kiểm tra xem các phần cứng tương ứng có được nối dây chính xác hay không.

Điều này giúp khắc phục sự cố một cách nhanh chóng.

Ví dụ mã bên dưới cung cấp cho đèn LED từ 2 đến 5 một mẫu cụ thể bằng cách chuyển chúng lần lượt theo chu kỳ.

const int kPinLed1 = 2 const int kPinLed2 = 3 const int kPinLed3 = 4 const int kPinLed4 = 5 void setup() { pinMode(kPinLed1, OUTPUT) pinMode(kPinLed2, OUTPUT) pinMode(kPinLed3, OUTPUT) pinMode(kPinLed4, OUTPUT) } void loop() { // turn on each of the LEDs in order digitalWrite(kPinLed1, HIGH) delay(100) digitalWrite(kPinLed2, HIGH) delay(100) digitalWrite(kPinLed3, HIGH) delay(100) digitalWrite(kPinLed4, HIGH) delay(100) // turn off each of the LEDs in order digitalWrite(kPinLed1, LOW) delay(100) digitalWrite(kPinLed2, LOW) delay(100) digitalWrite(kPinLed3, LOW) delay(100) digitalWrite(kPinLed4, LOW) }

Như bạn có thể nhận thấy, không có gì sai với mã, ngoại trừ thực tế là nó trông dài và do đó dễ mắc lỗi.

Tất nhiên có nhiều cách tốt hơn để viết đoạn mã trên, phần sau sẽ tiết lộ điều đó.

2.9 Giới thiệu Mảng

Mảng có thể là một nhóm các biến có thể được lập chỉ mục bằng các số chỉ mục. Ví dụ sau sẽ giúp chúng ta hiểu rõ hơn.

const int k_numLEDs = 4 const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5 void setup() { for(int i = 0 i pinMode(kPinLeds[i], OUTPUT) } } void loop() { for(int i = 0 i digitalWrite(kPinLeds[i], HIGH) delay(100) } for(int i = k_numLEDs - 1 i >= 0 i--){ digitalWrite(kPinLeds[i], LOW) delay(100) } }

OK, bây giờ chúng ta hãy đi qua từng phần và hiểu cách chúng thực sự hoạt động.

const int k_numLEDs = 4

Đoạn mã trên xác định có bao nhiêu phần tử tối đa mà chúng ta phải có trong mảng. Mã này giúp chúng ta trong các phần tiếp theo để đảm bảo rằng mọi thứ được viết trong một mảng và không có gì sau khi mảng kết thúc.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

Trong dòng tiếp theo này, chúng ta thiết lập cấu trúc mảng. Các số bên trong dấu ngoặc cho biết số phần tử trong mảng. Mặc dù, số lượng thực tế có thể đã được viết, nhưng viết dưới dạng hằng số hoạt động tốt hơn. Các giá trị thường có thể được nhìn thấy bên trong dấu ngoặc bằng dấu phẩy và chỉ định các giá trị cho mảng.

Khi bạn tìm thấy một mảng được đánh chỉ mục bằng số 0, điều này cho biết phần tử đầu tiên trong mảng, như được hiển thị trong code: k_LEDPins is k_LEDPins[0].

Tương tự, phần tử cuối cùng sẽ được hiển thị là k_LEDPins[3], vì số đếm từ 0 đến 3 là 4.

void setup() { for(int i = 0 i pinMode(kPinLeds[i], OUTPUT) } }

Đoạn mã trên cho thấy việc sử dụng vòng lặp để tiếp tục qua từng phần tử mảng và để đặt chúng là ĐẦU RA. Chúng tôi triển khai các dấu ngoặc vuông cùng với chỉ số để tiếp cận từng phần tử trong mảng.

Nếu bạn đang tự hỏi liệu có thể sử dụng pin # 2 để ghim # 5 mà không có mảng hay không, câu trả lời là có, hoàn toàn có thể. Nhưng trong ví dụ này, nó không được thực hiện bởi vì chúng tôi đã không làm theo cách đó. Trong các phần sau, bạn có thể loại bỏ cách tiếp cận mảng nếu các chân đầu ra đã chọn không thẳng hàng.

Tiếp tục, hãy xem khối mã tiếp theo làm gì:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH) delay(100) }

Tại đây, mã tiến hành qua từng đèn LED để BẬT chúng theo tuần tự với khoảng cách hoặc độ trễ là 100 mili giây.

for(int i = k_numLEDs - 1 i >= 0 i--){ digitalWrite(kPinLeds[i], LOW) delay(100) }

Việc sử dụng đoạn mã trên cho thấy cách ứng dụng của vòng lặp for có thể được sử dụng để di chuyển qua vòng lặp thậm chí theo thứ tự ngược lại.

Nó bắt đầu từ k_numLEDs - 1 bởi vì các mảng không được lập chỉ mục. Chúng tôi không bắt đầu từ k_LEDPins[4] vì điều đó sẽ dẫn đến việc vượt qua phần kết thúc của mảng.

Đoạn mã sử dụng> = 0 để kiểm tra sao cho phần tử đầu tiên ở chỉ mục 0 không bị bỏ sót hoặc bỏ qua.

Chương 3

Đầu vào là gì

Vì vậy, chúng ta đã học cách vận hành mọi thứ bằng Arduino. Trong chương này, chúng ta sẽ thảo luận về cách cảm nhận thế giới thực bằng cách giao tiếp các đầu vào từ các tham số bên ngoài.

3.1 Sử dụng nút bấm

Tất cả chúng ta đều biết nút nhấn là gì và nó hoạt động như thế nào. Nó là một loại công tắc hoặc nút kết nối tín hiệu từ giai đoạn mạch này sang giai đoạn mạch khác trong thời gian nó đang ở trạng thái trầm cảm và ngắt tín hiệu khi nhả ra.

3.1.1 Một nút và một đèn LED

Chúng tôi sẽ kết nối Arduino bằng một nút nhấn với Arduino theo các chi tiết được hiển thị ở trên và tìm hiểu cách làm việc và triển khai cơ bản của thiết lập.

Nút nhấn được chỉ định còn được gọi là nút nhấn công tắc vi mô, có tổng cộng 4 chân (2 cặp mỗi bên). Khi được đẩy, mỗi cặp chân được nối bên trong và cho phép kết nối hoặc dẫn truyền qua chúng.

Trong ví dụ này, chúng tôi chỉ sử dụng một cặp chân hoặc tiếp điểm này, cặp còn lại không liên quan và do đó bị bỏ qua.

Hãy tiếp tục áp dụng mã sau và kiểm tra xem nó có hoạt động không!

const int kPinButton1 = 2 const int kPinLed = 9 void setup() { pinMode(kPinButton1, INPUT) digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor pinMode(kPinLed, OUTPUT) } void loop() { if(digitalRead(kPinButton1) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Bạn có thể tìm thấy một vài thứ trông khác thường ở đây. Hãy tìm ra bước đi khôn ngoan.

void setup() { pinMode(kPinButton1, INPUT) digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor pinMode(kPinLed, OUTPUT) }

Điều đầu tiên chúng tôi làm là sửa lỗi buttonPin như là ĐẦU VÀO. Điều đó khá cơ bản, tôi biết.

“4 bit ripple carry adder Verilog ”

Tiếp theo, chúng tôi chỉ định CAO đến ĐẦU VÀO ghim. Bạn tự hỏi, làm thế nào nó có thể có thể viết bất cứ điều gì ở đầu vào? Chắc chắn, điều này có thể thú vị.

Trên thực tế, việc chỉ định CAO cho đầu vào Arduino sẽ bật điện trở kéo lên 20k Ohm bên trong BẬT (giá trị THẤP trên chân này sẽ TẮT).

Một câu hỏi khác mà bạn có thể đặt ra là điện trở kéo lên là gì. Tôi đã trình bày một bài toàn diện về điện trở kéo lên mà bạn học nó ở đây .

OK, tiếp tục, bây giờ chúng ta hãy xem mã vòng lặp chính:

void loop() { if(digitalRead(kPinButton1) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Khi bạn nhấn nút nhấn, chốt có dây được kết nối với đất, điều này làm cho THẤP vào ghim đó. Và trong khi ở điều kiện không được ép, cùng một chốt được giữ ở CAO hoặc + 5V qua điện trở kéo lên bên trong 20K.

Ở đây chúng tôi muốn Arduino sáng đèn LED khi nhấn nút nhấn (LOW), do đó chúng tôi viết CAO cho đầu ra cho mọi phản hồi của LOW từ nút nhấn, trong khi nó được nhấn.

3.1.2 Hai nút và một đèn LED

Chà, bạn có thể thắc mắc rằng hành động được hiển thị ở trên có thể được thực hiện mà không có Arduino. Tôi hiểu, tuy nhiên đây là một hòn đá tảng để tìm hiểu cách sử dụng nút nhấn với Arduno.

Cho đến thời điểm này, chúng tôi đã nghiên cứu cách viết mã cho công tắc BẬT (CAO) hoặc TẮT (THẤP) một đèn LED.

Bây giờ chúng ta hãy xem độ sáng của đèn LED có thể được điều khiển như thế nào với Arduino.

Nó có thể được thực hiện bằng hai phương pháp:

Bằng cách hạn chế lượng dòng điện đến đèn LED
Bằng cách sử dụng PWM hoặc điều chế độ rộng xung, trong đó nguồn cung cấp cho đèn LED được BẬT / TẮT ở một số tốc độ mong muốn rất nhanh, tạo ra độ chiếu sáng trung bình có cường độ phụ thuộc vào PWM.

Trong bảng Arduino, hỗ trợ PWM có sẵn trên các chân được đánh dấu bằng dấu ngã (~), đó là các chân 3, 4,5,9,10 và 11) ở 500Hz (500 lần một giây). Người dùng có thể cung cấp bất kỳ giá trị nào trong khoảng từ 0 đến 255, trong đó 0 đề cập đến không có CAO hoặc không có + 5V và 255 nói với Arduino luôn nhận được CAO hoặc + 5V. Để bắt đầu các lệnh này, bạn sẽ phải truy cập vào analogWrite () với giá trị mong muốn.

Bạn có thể giả sử PWM là x / 255 trong đó x là giá trị mong muốn bạn muốn gửi qua analogWrite().

Thiết lập Arduino và các thông số khác như hình trên.

const int kPinButton1 = 2 const int kPinButton2 = 3 const int kPinLed = 9 void setup() { pinMode(kPinButton1, INPUT) pinMode(kPinButton2, INPUT) pinMode(kPinLed, OUTPUT) digitalWrite(kPinButton1, HIGH) // turn on pullup resistor digitalWrite(kPinButton2, HIGH) // turn on pullup resistor } int ledBrightness = 128 void loop() { if(digitalRead(kPinButton1) == LOW){ ledBrightness-- } else if(digitalRead(kPinButton2) == LOW){ ledBrightness++ } ledBrightness = constrain(ledBrightness, 0, 255) analogWrite(kPinLed, ledBrightness) delay(20) }

Bạn có thể tìm thấy 3 dòng ở đây cần một số giải thích.

ledBrightness = constrain(ledBrightness, 0, 255) 25 analogWrite(kPinLed, ledBrightness) 26 delay(20)

Dòng: ledBrightness = constrain(ledBrightness, 0, 255) minh họa một chức năng duy nhất bên trong Arduino được gọi là bindin ().

Hàm nội bộ này bao gồm mã tương tự như sau:

int ràng buộc (int value, int min, int max)
{ if(value > max){ value = max } if(value value = min } return value }

Tất cả các mã được thảo luận trước khi bắt đầu với vô hiệu , có nghĩa là không trả về bất cứ thứ gì (void). Trong khi đoạn mã trên bắt đầu bằng int , chỉ ra rằng nó trả về một số nguyên. Chúng ta sẽ thảo luận thêm về trong các phần sau, tại thời điểm này chỉ cần nhớ rằng một số nguyên không có bất kỳ phần phân số nào.

Đúng vậy, điều này ngụ ý, mã: ledBrightness = constrain(ledBrightness, 0, 255) gán dấu ledBrightness to be within the range of 0 and 255.

Dòng tiếp theo sử dụng analogWrite để ra lệnh cho Arduino ứng dụng PWM trên chân đã chọn với giá trị mong muốn.

Dòng tiếp theo tạo ra độ trễ 20 mili giây, điều này để đảm bảo rằng chúng tôi không điều chỉnh tốc độ nhanh hơn 50 Hz hoặc 50 lần một giây. Điều này là do con người có thể chậm hơn nhiều so với Arduino. Do đó, nếu độ trễ không được thực hiện, chương trình có thể khiến chúng ta cảm thấy rằng việc nhấn nút đầu tiên sẽ TẮT đèn LED và nhấn nút thứ hai để đèn BẬT (hãy tự mình thử để xác nhận).

3.2 Chiết áp

Hãy tiếp tục và học cách sử dụng chiết áp với Arduino.

Để biết chiết áp hoặc nồi hoạt động như thế nào, bạn có thể đọc phần này bài báo .

Kết nối các thông số được hiển thị với Arduino của bạn như hình trên.

Một chậu sẽ có 3 thiết bị đầu cuối. Terminasl ở giữa sẽ kết nối với ANALOG IN 0 trên Arduino. Hai đầu cuối bên ngoài khác có thể được kết nối với các đường cung cấp + 5V và 0V.

Hãy lập trình và kiểm tra kết quả:

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinPot, INPUT) pinMode(kPinLed, OUTPUT) } void loop() { int ledBrightness int sensorValue = 0 sensorValue = analogRead(kPinPot) ledBrightness = map(sensorValue, 0, 1023, 0, 255) analogWrite(kPinLed, ledBrightness) }

Bạn sẽ tìm thấy một vài thứ có thể trông hoàn toàn mới và không có trong bất kỳ mã nào trước đây của chúng tôi.

Hằng số kPinPot được gán là A0, trong đó A là phím tắt để mô tả một trong các chân tương tự. Tuy nhiên A0 cũng đề cập đến chân # 14, A1 đến chân # 15, v.v. và những thứ này cho phép bạn được sử dụng làm đầu vào / đầu ra kỹ thuật số trong trường hợp bạn hết chân cho một thử nghiệm. Nhưng hãy nhớ rằng bạn không thể sử dụng chân kỹ thuật số làm chân tương tự.
Dòng: ledBrightness = map(sensorValue, 0, 1023, 0, 255) trình bày một chức năng bên trong mới trong Arduino được gọi là bản đồ(). Tính năng này hiệu chỉnh lại từ một phạm vi nhất định sang một phạm vi khác, được gọi là map (value, fromLow, fromHigh, toLow, toHigh). Điều này có thể trở nên quan trọng vì analogueRead đưa ra giá trị trong phạm vi 0-1023, nhưng analogWrite có thể chấp nhận giá trị từ 0-255.

Bạn có thể nghĩ rằng vì có thể điều khiển độ sáng của đèn LED thông qua điện trở thay đổi, nên chỉ cần một chiếc nồi là đủ cho mục đích, tại sao lại sử dụng Arduino. Chà, một lần nữa, nó chỉ là nền tảng, để chỉ ra cách một cái nồi có thể được cấu hình với Arduino.

Không vấn đề gì, bây giờ chúng ta sẽ làm điều gì đó không thể thực hiện được nếu không có Arduino.

Trong thí nghiệm này, chúng ta sẽ xem cách sử dụng điện trở thay đổi của nồi để kiểm soát tốc độ hoặc tốc độ nhấp nháy của đèn LED.

Đây là chương trình:

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { int sensorValue sensorValue = analogRead(kPinPot) digitalWrite(kPinLed, HIGH) delay(sensorValue) digitalWrite(kPinLed, LOW) delay(sensorValue) }

3.2.3 Tránh chậm trễ ()

Đoạn mã trên có vẻ tốt, nhưng đèn LED không thể kiểm tra giá trị nồi cho đến khi nó trải qua mỗi chu kỳ đầy đủ. Đối với sự chậm trễ lâu hơn, quá trình này sẽ khiến người dùng phải đợi lâu hơn để xem phản hồi nồi trong khi anh ta di chuyển nó. Sự chậm trễ này có thể tránh được với một số chương trình thông minh, để nó cho phép người dùng kiểm tra giá trị mà không có độ trễ tối thiểu. Đây là mã.

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinLed, OUTPUT) } long lastTime = 0 int ledValue = LOW void loop() { int sensorValue sensorValue = analogRead(kPinPot) if(millis() > lastTime + sensorValue){ if(ledValue == LOW){ ledValue = HIGH } else{ ledValue = LOW } lastTime = millis() digitalWrite(kPinLed, ledValue) } }

Vậy điều đó có gì khác biệt trong đoạn mã trên? Đó là dòng sau đây tạo ra sự khác biệt.

long lastTime = 0

Cho đến phần này, chúng ta đã thảo luận về biến int. Tuy nhiên, có thể có nhiều biến kiểu khác mà bạn có thể truy cập. Danh sách e có thể đọc dưới đây:

Hiện tại, có thể chỉ cần biết rằng để lưu trữ số lượng tương đối lớn cho int biến, bạn có thể sử dụng thuật ngữ Dài hoặc một int dài.

Ở đây bạn có thể thấy một chức năng thú vị khác được gọi là mili ().

Điều này tạo ra khoảng thời gian tính bằng mili giây mà Arduino đã hoạt động trong quá trình hoạt động của nó ngay từ đầu (điều này sẽ đặt lại về 0 sau mỗi 50 ngày). Ở đây nó trả về rất lâu vì nếu nó trả về int , đếm trong thời gian dài có thể không thực hiện được. Bạn có thể trả lời chính xác trong bao lâu? Đáp số là 32,767 giây.

Do đó, thay vì sử dụng delay (), chúng tôi kiểm tra mili () và ngay khi số mili giây cụ thể trôi đi, chúng tôi sẽ thay đổi đèn LED. Do đó, chúng tôi lưu trữ thời gian chúng tôi thay đổi lần cuối trong lần cuối cùng biến, để nó cho phép chúng tôi kiểm tra lại bất cứ khi nào muốn.

3.3 Đèn LED RGB

Cho đến nay chúng tôi đã chơi với một đèn LED màu duy nhất. Mặc dù màu LED có thể thay đổi bằng cách thay thế đèn LED bằng màu khác, nhưng sử dụng đèn LED RGB thì sao để thay đổi màu đèn LED mà không cần thay đổi đèn LED?

Đèn LED RGB về cơ bản là một đèn LED có đèn LED màu đỏ, xanh lục và xanh lam được nhúng và hợp nhất thành một đèn LED duy nhất. Nó có một dây dẫn chung đi đến mặt đất hoặc đường ray cung cấp 0V trong khi 3 dây dẫn còn lại được cung cấp các tín hiệu tích cực PWM đa dạng để thực hiện dự định trộn màu .

Bạn có thể thiết lập dây như hình dưới đây:

Nó có thể trông hơi phức tạp, nhưng thực sự nó là một bản sao của thiết kế điều khiển đèn LED trước đó của chúng tôi sử dụng PWM.

Đây là mã chương trình thực hành:

const int kPinPot1 = A0 const int kPinPot2 = A1 const int kPinPot3 = A2 const int kPinLed_R = 6 const int kPinLed_G = 10 const int kPinLed_B = 11 void setup() { pinMode(kPinLed_R, OUTPUT) pinMode(kPinLed_G, OUTPUT) pinMode(kPinLed_B, OUTPUT) } void loop() { int potValue int ledValue potValue = analogRead(kPinPot1) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_R, ledValue) potValue = analogRead(kPinPot2) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_G, ledValue) potValue = analogRead(kPinPot3) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_B, ledValue) }

Sau khi tải lên mã này, chỉ cần xem cách điều chỉnh nồi tạo ra hiệu ứng ánh sáng thú vị trên RGB, đó có thể là một niềm vui thực sự.

Bạn sẽ thấy rằng khi tất cả 3 bình được di chuyển vị trí tối đa, thay vì một màu trắng, bạn sẽ thấy màu đỏ. Điều này là do màu đỏ là màu nổi bật nhất trong 3 màu và do đó chiếm ưu thế trong tình huống này. Tuy nhiên, bạn có thể thử nghiệm với chức năng bản đồ() , trước khi thực hiện nó với phần màu đỏ của đèn LED, để tạo ra sự cân bằng hợp lý hơn.

Âm thanh với Arduino

Trong phần này, chúng ta sẽ tìm hiểu cách thêm âm thanh và nhạc cơ bản vào thiết lập Arduino.

Chúng ta sẽ xem cách chuyển tín hiệu sang loa được kết nối với tần số mong muốn.

Nói chính xác hơn, một nốt A giữa sẽ được thử, đó là một nốt có tần số 440 Hz.

Để làm điều này, chúng tôi chỉ cần chơi một nốt A ở giữa và tối ưu hóa tín hiệu sóng sin với sóng vuông.

Ngoài ra, chúng tôi sẽ tính toán khoảng thời gian loa có thể BẬT bằng cách áp dụng công thức:

timeDelay = 1 giây / 2 x toneFrequency.

timeDelay = 1 giây / 2 x 440

timeDelay = 1136 micro giây

4.1 Hãy kết nối bảng Arduino

4.2 Thêm ghi chú đơn giản

Chúng tôi đã thảo luận về chức năng sự chậm trễ() trong đó đơn vị tính bằng mili giây (giây / 1000), tuy nhiên bạn sẽ tìm thấy một hàm khác delayMicroseconds() trong đó đơn vị tính bằng micro giây, (mili giây / 1000).

Đối với thiết lập hiện tại, chúng tôi lập trình mã để chuyển đổi + 5V BẬT / TẮT trên chân đã chọn được liên kết với loa, với tốc độ 440 xung mỗi giây.

Nhớ lại, trong cuộc thảo luận trước, chúng tôi đã xác định giá trị 1136 micro giây cho ghi chú âm thanh dự định.

Vì vậy, đây là chương trình cho điều này, cho phép bạn nghe một nốt âm thanh 440 Hz ngay khi bạn lập trình arduino với một loa được kết nối.

const int kPinSpeaker = 9 const int k_timeDelay = 1136 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { digitalWrite(kPinSpeaker, HIGH) delayMicroseconds(k_timeDelay) digitalWrite(kPinSpeaker, LOW) delayMicroseconds(k_timeDelay) }

Với ứng dụng trên, có thể tạo ghi chú âm thanh, điều này cũng có nghĩa là chúng ta có thể tạo một bản nhạc theo sự lựa chọn của riêng mình.

Từ đoạn mã, chúng tôi hiểu rằng Arduino bao gồm một số chức năng tích hợp góp phần bổ sung vào việc tạo ra âm nhạc.

Điều thứ nhất là tấn() hoạt động với 2 phần tử cùng với phần tử tùy chọn thứ 3, được chỉ định là giai điệu (pin, tần số, thời lượng). hoặc là giai điệu (pin, tần số)

Cả hai đều được chỉ định để thực thi tương ứng với khoảng thời gian do bạn chỉ định.

Trong trường hợp không có khoảng thời gian, nhạc sẽ tiếp tục phát cho đến khi có cuộc gọi tấn() được thực thi lại hoặc cho đến khi bạn thực thi không một ().

Điều này sẽ cần được thực hiện bằng cách sử dụng chức năng trì hoãn trong trường hợp chơi nhạc là điều cơ bản duy nhất mà bạn đang thực hiện.

Khoảng thời gian có thể rất quan trọng vì nó cho phép cung cấp thời gian cho thời lượng nhạc được phát, vì vậy bạn có thể rảnh để làm những việc khác. Ngay sau khi hết thời lượng, nhạc sẽ dừng.

Chức năng tiếp theo không một () xử lý một tham số duy nhất và dừng âm đã chọn trên một chốt được chỉ định cụ thể.

Một cảnh báo đặc biệt: Bất cứ lúc nào khi tấn() được thực hiện, chức năng PWM trên chân 3 và 11 sẽ ngừng hoạt động.

Do đó, bất cứ khi nào phần đính kèm loa được sử dụng trong chương trình, hãy đảm bảo không sử dụng chân cắm đã đề cập cho loa, thay vào đó hãy thử một số chân khác cho phần đính kèm loa.

OK, đây là chương trình để triển khai âm nhạc trên loa, mặc dù nó không phải là một bản nhạc thực sự mà là một nốt C thang âm cơ bản.

#define NOTE_C4 262 #define NOTE_D4 294 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_G4 392 #define NOTE_A4 440 #define NOTE_B4 494 #define NOTE_C5 523 const int kPinSpeaker = 9 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { tone(kPinSpeaker, NOTE_C4, 500) delay(500) tone(kPinSpeaker, NOTE_D4, 500) delay(500) tone(kPinSpeaker, NOTE_E4, 500) delay(500) tone(kPinSpeaker, NOTE_F4, 500) delay(500) tone(kPinSpeaker, NOTE_G4, 500) delay(500) tone(kPinSpeaker, NOTE_A4, 500) delay(500) tone(kPinSpeaker, NOTE_B4, 500) delay(500) tone(kPinSpeaker, NOTE_C5, 500) delay(500) noTone(kPinSpeaker) delay(2000) }

Trong đoạn mã trên, bạn có thể nhận thấy điều gì đó mới và đó là #định nghĩa .

Thuật ngữ này hoạt động giống như một lệnh tìm kiếm và thay thế cho máy tính trong khi quá trình biên dịch đang được thực hiện.

Bất cứ khi nào nó tìm thấy thứ đầu tiên trước một khoảng trắng, nó sẽ thay thế nó bằng phần còn lại của dòng (được gọi là macro).

Vì vậy, trong ví dụ này khi máy tính thấy NOTE_E4 nó nhanh chóng thay thế nó với số lượng 330.

Để có thêm ghi chú và tùy chỉnh, bạn có thể tham khảo một tệp trong thẻ USB của bạn có tên cao độ.h , nơi hầu hết các tần số có thể được tìm thấy theo sở thích của bạn.

4.4 Âm nhạc với các chức năng

Đoạn mã trên có vẻ tốt, nhưng có vẻ như có nhiều lần lặp lại, nên có một số phương pháp để rút ngắn những lần lặp lại này, phải không?

Cho đến nay chúng tôi đã làm việc với hai chức năng thiết yếu đi kèm với Arduino. Bây giờ có thể đã đến lúc chúng ta tạo ra các chức năng của riêng mình.

Mỗi hàm phải bắt đầu bằng loại biến mà nó có thể được liên kết. Ví dụ hàm vô hiệu đề cập đến kiểu không trả về gì do đó có tên là void. Lưu ý, chúng tôi đã thảo luận về danh sách các biến trong các phần trước của chúng tôi, bạn có thể muốn tham khảo chúng.

Do đó, tên hàm cụ thể nhận được một dấu ngoặc đơn mở '(' theo sau là danh sách các tham số được phân tách bằng dấu phẩy.

Mỗi tham số nhận được kiểu của nó cùng với một tên và cuối cùng là một ')' dấu ngoặc đơn.

Các tham số này có thể được áp dụng trong hàm dưới dạng các biến.

Hãy xem một ví dụ dưới đây, nơi chúng tôi phát triển một hàm được gọi là ourTone () được thiết kế để hợp nhất tấn() với sự chậm trễ() dòng, theo cách mà chức năng ngừng quay trở lại cho đến khi nốt nhạc kết thúc phát âm báo.

Chúng tôi triển khai các chức năng này trong mã trước của chúng tôi và lấy chương trình bên dưới, hãy xem những dòng cuối cùng:

Các hàm có thể cực kỳ tiện dụng để làm cho một chương trình dễ hiểu hơn.

Sau đây là một ví dụ mà chúng ta có thể chỉ định lựa chọn giai điệu mà chúng ta muốn phát bằng cách sử dụng hai mảng. Một mảng để giữ lại các nốt, mảng kia để giữ lại nhịp.

#include 'pitches.h' int kPinSpeaker = 9 #define NUM_NOTES 15 const int notes[NUM_NOTES] = // a 0 represents a rest { NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4, 0 } const int beats[NUM_NOTES] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 } const int beat_length = 300 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { for (int i = 0 i if (notes[i] == 0) { delay(beats[i] * beat_length) // rest } else { ourTone(notes[i], beats[i] * beat_length) } // pause between notes noTone(kPinSpeaker) delay(beat_length / 2) } } void ourTone(int freq, int duration) { tone(kPinSpeaker, freq, duration) delay(duration) }

Bạn có thể thấy rõ ràng trên dòng đầu tiên phần giới thiệu của #include tuyên bố. Công việc của câu lệnh này là chọn toàn bộ tệp giữa các dấu ngoặc kép và đặt nó vào vị trí của #include tuyên bố. Theo các quy tắc tiêu chuẩn, chúng được đặt nghiêm ngặt khi bắt đầu chương trình.

Chương 5

Đo nhiệt độ

Chỉ cần nhắc lại, hãy nhớ thay vì viết toàn bộ các chương trình lớn, luôn là điều khôn ngoan khi viết và phân tích các phần nhỏ của mã, điều này giúp tìm ra lỗi nhanh chóng.

5.1 Màn hình nối tiếp

Cho đến nay, các mã mà chúng ta đã thảo luận dường như không dễ dàng hơn để cho phép khắc phục sự cố nhanh. Tại đây, chúng tôi sẽ cố gắng giúp mọi thứ dễ dàng hơn cho việc giám sát và giải quyết vấn đề có thể xảy ra dễ dàng hơn.

Arduino có một tính năng cho phép nó 'nói chuyện lại' với máy tính. Bạn có thể quan sát thấy rằng pin0 và pin1 được đánh dấu là RX một TX bên cạnh nhau. Các chân này thực sự được theo dõi bởi một vi mạch riêng biệt trong Arduino, giúp nâng cấp chúng để đọc qua cáp USB trong khi cắm vào PC.

Phần bên dưới hiển thị một chương trình chính thức đầy đủ, vui lòng tiếp tục, chúng ta sẽ tìm hiểu về các mục mới trong mã sau đó. Mã này giống như phần 2.2 đã trình bày ngoại trừ thực tế là nó bao gồm một số dữ liệu bổ sung để cho phép chúng tôi xác định nó được mã hóa để làm gì.

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) Serial.begin(9600) } int delayTime = 1000 void loop() { delayTime = delayTime - 100 if(delayTime <= 0){ // If it would have been zero or less, reset it. delayTime = 1000 } Serial.print('delayTime = ') Serial.println(delayTime) digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

Bạn có thể xác định hai điều mới ở đây, một dòng mới trong thiết lập() chức năng.

Serial.begin(9600)

Dòng này chỉ đơn giản thể hiện sự cần thiết của việc sử dụng Serial1 mã để thực thi nó với 9600 baud. (ở đây nối tiếp đề cập đến chút ít được gửi lần lượt và baud có nghĩa là tốc độ mà nó được gửi). Giá trị baud này và giá trị bên trong màn hình nối tiếp (chúng ta sẽ tìm hiểu điều này sau) phải bằng nhau, nếu không dữ liệu trong màn hình nối tiếp sẽ hiển thị rác. 9600 là tiêu chuẩn trở nên thuận tiện hơn để sử dụng.

Mục nhập mới thứ hai như sau

Serial.print('delayTime = ') Serial.println(delayTime)

Ở đây dòng thứ hai gợi ý rằng thứ tiếp theo đi ra từ cổng nối tiếp sẽ bắt đầu ở dòng tiếp theo. Đó là cách đường thứ hai khác với đường nắm tay.

Một điều nữa bạn có thể thấy là dấu ngoặc kép ('). Đây được gọi là một chuỗi, sẽ chỉ được sử dụng giống như các hằng ở đây, vì thảo luận thêm về chủ đề này có thể quá phức tạp và vượt quá phạm vi.

OK, bây giờ chúng ta có thể tải lên đoạn mã trên trong Arduino và xem điều gì sẽ xảy ra.

Cái gì, rất tiếc dường như không có gì xảy ra, đèn LED pin Arduino # 13 nhấp nháy và dừng lại, trong khi đèn LED Tx vẫn nhấp nháy.

Đó là bởi vì cửa sổ Serial Monitor chưa được sửa.

Bạn cần nhấp vào ô Serial Monitor trong IDE của bạn như hình trên. Đừng quên kiểm tra tốc độ truyền nằm ở dưới cùng bên phải, theo mặc định nó phải là 9600 và sẽ khớp với mã. Nếu không chắc chắn hãy chọn 9600.

Video clip sau đây giải thích cách thực hiện.

https://youtu.be/ENg8CUyXm10

Bây giờ chúng ta hãy tiếp tục và tìm hiểu cách tính năng Serial Monitor ở trên có thể hỗ trợ xử lý đo nhiệt độ bằng Arduino

Chúng tôi sẽ sử dụng IC TMP36 làm cảm biến nhiệt độ, có phạm vi từ -40 đến 150 độ C.

Thiết lập có thể được nhìn thấy bên dưới:

Đoạn mã sau sẽ bắt đầu đo nhiệt độ bằng cách đọc đầu ra từ cảm biến TMP36 và bằng cách gửi chúng đến màn hình nối tiếp của ID.

const int kPinTemp = A0 void setup() { Serial.begin(9600) } void loop() { float temperatureC = getTemperatureC() Serial.print(temperatureC) Serial.println(' degrees C') // now convert to Fahrenheit float temperatureF = convertToF(temperatureC) Serial.print(temperatureF) Serial.println(' degrees F') delay(500) } float getTemperatureC() { int reading = analogRead(kPinTemp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 } float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

Hãy hiểu mã từ đầu.

float temperatureC = getTemperatureC()

Ở đây bạn có thể thấy rằng chúng tôi đã bao gồm loại biến Phao nổi.

Đây là loại biến duy nhất có tính năng lưu trữ mọi thứ ngoại trừ số nguyên (số không có phần thập phân hoặc phần thập phân).

Độ chính xác của một biến float có thể lên đến 6 đến 7 chữ số.

Mã liền kề getTemperatureC() là chức năng của riêng chúng tôi, tính toán toán học và chuyển đổi chênh lệch điện áp cảm nhận được từ cảm biến TMP36 thành độ C.

float getTemperatureC() { int reading = analogRead(kPinTemp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 }

Trong phần tiếp theo của mã, kể từ thuật ngữ analogIn() được gán để trả về một hình trong khoảng từ 1 đến 1023, chúng tôi có thể đánh giá điện áp từ cảm biến bằng cách nhân số đọc của chúng tôi với 5 và sau đó chia cho 1024.

Cảm biến TMP36 được chỉ định để tạo ra 0,5V ở 0 độ C và sau đó tạo ra 10mV cho mỗi lần tăng độ C.

Đây là giá trị gần đúng mà chúng tôi có thể tạo ra thông qua các phép tính:

Bạn có thể coi đây là hàm đầu tiên của mình trả về một số giá trị (lưu ý rằng tất cả các hàm còn lại cho đến nay không trả về bất kỳ giá trị nào vì chúng thuộc loại vô hiệu ).

Bạn có thể hiểu rằng để nhận được giá trị từ một hàm, bạn chỉ cần thêm trở về tiếp theo là số bạn muốn trả lại.

Khi chúng tôi nói trở về nó có nghĩa là hàm trả về một phản hồi hoặc một phản hồi bất cứ khi nào nó được gọi, có thể được áp dụng cho một biến.

Khi điều này được gửi đến Serial Monitor, việc đọc được chuyển đổi thành Fahrenheit thông qua convertToF ().

float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

Chức năng này nhận phạm vi độ C và chuyển nó thành độ F.

Để chuyển đổi độ F sang độ C, chúng tôi thực hiện công thức Fahrenheit = 9 / 5 (độ C) + 32.

5.3 Giao diện màn hình LCD

Bây giờ chúng ta hãy nghiên cứu cách giao diện hoặc kết nối Màn hình LCD với Arduino để hiển thị hình ảnh cho các đầu ra cần thiết.

Trong ứng dụng của chúng tôi, chúng tôi sẽ sử dụng một màn hình LCD đồ họa 84x48, có 84 pixel hoặc các chấm theo chiều ngang và độ phân giải 48 pixel theo chiều dọc. Vì một bộ điều khiển chuyên dụng trở nên bắt buộc đối với tất cả các màn hình LCD, nên thiết bị hiện tại cũng kết hợp một bộ điều khiển ở dạng bộ điều khiển PCD8544.

Trong hướng dẫn này, chúng tôi sẽ kết nối mô-đun LCD được chỉ định ở trên với Arduino và áp dụng các quy trình nhất định để tạo tin nhắn văn bản trên màn hình.

Trong hình sau, bạn có thể tìm thấy các chi tiết liên quan đến giao diện của màn hình LCD, cùng với một Bộ điều chỉnh điện áp 3.3V . Bộ điều chỉnh này là cần thiết vì màn hình LCD được chỉ định hoạt động với nguồn cung cấp 3.3V.

Bạn cũng có thể thấy 8 sơ đồ chân từ mô-đun LCD, thông số kỹ thuật sơ đồ chân có thể được nghiên cứu từ bảng sau:

Bây giờ chúng ta hãy xem cách chúng ta có thể kết nối màn hình LCD và các thông số liên quan với Arduino của chúng ta. Các chi tiết có thể được hình dung trong hình minh họa bên dưới:

5.4 Giao tiếp với màn hình LCD

Mặc dù có thể viết các mã phức tạp để tương tác với LCD từ Arduino, nhưng chúng ta sẽ học cách làm điều tương tự bằng cách sử dụng các thư viện.

Các thư viện bao gồm nhiều loại mã có thể được áp dụng nhanh chóng cho một chương trình Arduino đã chọn.

Điều này cho phép người dùng gọi một hàm một cách dễ dàng mà không cần phải trải qua công việc viết mã phức tạp.

5.4.1 Cách cài đặt thư viện

Đối với điều này, bạn sẽ phải tạo một thư mục được gọi là thư viện trong máy tính Arduino IDE của bạn, như đã giải thích đây

5.4.2 Thực hiện các hoạt động LCD

“vai trò của bộ điều khiển và alu là gì? ”

Cũng giống như cách tiếp cận trước đây của chúng tôi, trước tiên chúng tôi sẽ kiểm tra toàn bộ mã và sau đó cố gắng hiểu chi tiết của các dòng riêng lẻ.

#include const int kPin_CLK = 5 const int kPin_DIN = 6 const int kPin_DC = 7 const int kPin_RESET = 8 PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) void setup() { lcd.init() lcd.setCursor(0,0) lcd.print('Hello, World!') } void loop() { lcd.setCursor(0,1) lcd.print(millis()) }

Dòng bao gồm mã #include

Mã #include hướng dẫn PC nhận tệp được đề cập và thay thế phần tử #include bằng nội dung tệp trong quá trình biên dịch chương trình.

Phần tử #include có thể có dấu ngoặc nhọn cho biết tìm kiếm trong thư mục thư viện, hoặc nó cũng có thể có dấu ngoặc kép cho biết tìm kiếm trong cùng một thư mục mà chương trình nằm trong đó.

Các dòng mã tiếp theo thể hiện sơ đồ chân của màn hình LCD và sau đó chúng tôi viết một dạng biến mới:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Ở đây chúng ta đang biểu thị một biến có tên lcd có kiểu PCD8544 và hướng dẫn PC định dạng lại sơ đồ chân của nó được liên kết với Arduino.

Trong quá trình này, chúng tôi mô tả biến cho PC bằng cách hướng dẫn cách pin clk, din, dc và reset được giao tiếp với Arduino.

void setup() { lcd.init() lcd.setCursor(0,0) lcd.print('Hello, World!') }

Dòng lcd.init() khởi tạo hoạt động của LCD. Khi điều này được thực thi, dòng tiếp theo thực thi con trỏ ở phía trên bên trái của màn hình. Và dòng tiếp theo tiếp theo cố gắng in thông báo 'Hello, World'.

Điều này trông khá giống với kỹ thuật mà chúng tôi gửi tin nhắn qua màn hình nối tiếp. Sự khác biệt duy nhất là việc sử dụng mã lcd.print thay vì serial.print.

Khối mã tiếp theo thực sự được gọi lặp lại.

void loop() { lcd.setCursor(0,1) lcd.print(millis()) }

Sử dụng dòng này lcd.setCursor(0,1) chúng tôi cố định con trỏ vào cột thứ 0 ở ngoài cùng bên trái của hàng đầu tiên, trên màn hình LCD.

Dòng tiếp theo sử dụng một phím tắt: lcd.print(millis())

Nếu bạn nhớ lại chúng tôi đã làm việc với millis() trong các mã trước đây của chúng tôi, chúng tôi cũng có thể áp dụng tương tự ở đây thông qua các mã:

long numMillis = millis() lcd.print(numMillis)

Tuy nhiên, vì thực tế là ở đây không có khoảng thời gian tính bằng mili giây nào được tham gia, do đó chúng tôi thực hiện nó bằng cách gửi millis() hàm trực tiếp tới lcd.print() .

5.5 Kết hợp Toàn bộ Điều

OK, bây giờ chúng ta hãy kết hợp tất cả các mã chúng ta đã học ở trên để tạo mạch nhiệt độ màn hình LCD và hãy xem nó trông như thế nào:

#include const int kPin_CLK = 5 const int kPin_DIN = 6 const int kPin_DC = 7 const int kPin_RESET = 8 const int kPin_Temp = A0 PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) void setup() { lcd.init() lcd.setCursor(10,0) lcd.print('Temperature:') } void loop() { float temperatureC = getTemperatureC() // now convert to Fahrenheit float temperatureF = convertToF(temperatureC) lcd.setCursor(21,1) lcd.print(temperatureC) lcd.print(' C') lcd.setCursor(21,2) lcd.print(temperatureF) lcd.print(' F') delay(100) } float getTemperatureC() { int reading = analogRead(kPin_Temp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 } float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

Mọi thứ trông chuẩn trong chương trình trên, ngoại trừ việc sử dụng hàm setCursor () . Điều này được sử dụng để căn chỉnh văn bản càng xa càng tốt xung quanh trung tâm của màn hình.

Tuyệt quá! Và xin chúc mừng, bạn vừa lập trình chỉ báo nhiệt độ LCD nhỏ của riêng mình bằng Arduino.

Ứng dụng Arduino thực tế

Vì, tại thời điểm này, chúng ta đã bao gồm toàn diện các kỹ thuật lập trình khác nhau một cách chi tiết, đã đến lúc khắc phục chúng bằng cách áp dụng chúng cho một vài triển khai thực tế hữu ích.

Chúng ta sẽ bắt đầu với các cảm biến và xem cách các thiết bị cảm biến có thể được sử dụng với Arduino bằng cách thực thi một vài mã mẫu.

7.1 Giới thiệu về cảm biến

Trong hướng dẫn này, chúng ta sẽ tìm hiểu về nhiều loại cảm biến có thể được sử dụng với Arduino. Chúng có thể bao gồm các thiết bị như cảm biến ánh sáng LDR, cảm biến hiệu ứng từ trường, cảm biến độ nghiêng, cảm biến rung, cảm biến áp suất, v.v.

Chúng tôi sẽ bắt đầu với giao diện của cảm biến ánh sáng LDR với Arduino, như được hiển thị trong sơ đồ sau:

Như chúng ta đã biết, LDR là một thiết bị điện trở phụ thuộc ánh sáng có điện trở phụ thuộc vào cường độ của sự cố xung quanh trên bề mặt của nó.

Cường độ ánh sáng tỷ lệ nghịch với giá trị điện trở của LDR.

Ở đây chúng ta sẽ tìm hiểu cách thuộc tính này có thể được tích hợp với Arduino để thực thi một ứng dụng hữu ích:

Mã chương trình hoàn chỉnh có thể được hình dung như dưới đây:

const int kPin_Photocell = A0 void setup() { Serial.begin(9600) } void loop() { int value = analogRead(kPin_Photocell) Serial.print('Analog Reading = ') Serial.print(value) if(value <200){ Serial.println(' - Dark') }else if(value <400){ Serial.println(' - Dim') } else if(value <600){ Serial.println(' - Light') } else if(value <800){ Serial.println(' - Bright') } else{ Serial.println(' - Very Bright') } delay(1000) }

Tất cả các tham số được sử dụng trong mã đã được thảo luận trong khóa học của chúng tôi mà chúng tôi đã học cho đến nay. Bạn có thể kiểm tra các dòng bằng cách tham khảo các phần có liên quan.

Các giá trị được chọn ngẫu nhiên, bạn có thể dễ dàng thay đổi theo sở thích của riêng mình.

Cảm biến độ nghiêng

Cảm biến độ nghiêng là một thiết bị đơn giản có thể được sử dụng để phát hiện hành động nghiêng trên bất kỳ vật thể nào được lắp đặt. Về cơ bản, thiết bị có một quả bóng kim loại bên trong, khi nghiêng sẽ lăn qua một cặp tiếp điểm gây ra sự dẫn truyền qua các điểm tiếp xúc đó. Các tiếp điểm này được kết thúc như là các dây dẫn của công tắc nghiêng, được sử dụng với mạch bên ngoài để phát hiện sự dẫn điện do tác động nghiêng và kích hoạt ứng dụng đầu ra mong muốn.

Bây giờ chúng ta hãy xem cách một cảm biến độ nghiêng thiết bị có thể được kết nối. Hình ảnh dưới đây cho chúng ta một ý tưởng về cấu hình hoàn chỉnh:

cảm biến độ nghiêng tương tác với Arduino

const int kPin_Tilt = 3 const int kPin_LED = 13 void setup() { pinMode(kPin_Tilt, INPUT) digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor pinMode(kPin_LED, OUTPUT) } void loop() { if(digitalRead(kPin_Tilt) == HIGH){ digitalWrite(kPin_LED, LOW) } else{ digitalWrite(kPin_LED, HIGH) } }

Trong ví dụ này, đèn LED pin # 13 mặc định được sử dụng làm chỉ báo độ nghiêng.

Bạn có thể thấy rõ ràng việc bao gồm điện trở kéo lên ở đây, khá giống với những gì chúng ta đã làm trong phần 3.1. Do đó, thuật ngữ LOW chỉ ra rằng chức năng nghiêng không được kích hoạt.

7.4 Rơ le công tắc sậy (Rơ le kích hoạt nam châm thu nhỏ)

Bây giờ chúng ta hãy xem cách kết nối công tắc rơ le hoặc cảm biến từ trường với Arduino. Rơ le sậy là một loại công tắc kích hoạt hoặc dẫn điện khi có từ trường hoặc nam châm đến gần nó. Về cơ bản, nó có một cặp tiếp điểm sắt từ bên trong một vỏ bọc bằng thủy tinh thu nhỏ tham gia hoặc tiếp xúc do lực kéo từ trường bất cứ khi nào một từ trường ở gần nó. Khi điều này xảy ra, các đầu nối của các tiếp điểm hiển thị dẫn do đóng các tiếp điểm.

Ở đây chúng tôi cũng sử dụng đèn LED pin # 13 để chỉ ra phản ứng. Bạn có thể kết nối đèn LED bên ngoài từ chân này nếu được yêu cầu theo giải thích trước đó của chúng tôi.

const int kPinReedSwitch = 2 const int kPinLed = 13 void setup() pinMode(kPinReedSwitch, INPUT) digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor pinMode(kPinLed, OUTPUT) } void loop() { if(digitalRead(kPinReedSwitch) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Các thuật ngữ mã nên quen thuộc và tự giải thích.

7.5 Cảm biến rung sử dụng đầu dò Piezo

Trong chương trình mẫu tiếp theo, chúng ta sẽ xem cách đầu dò piezo có thể được sử dụng làm cảm biến rung để chiếu sáng đèn LED thông qua Arduino.

Phần tử piezo thực chất là một thiết bị tạo ra rung động hoặc dao động khi một tần số được áp dụng trên các đầu cuối của nó. Tuy nhiên, cùng một piezo có thể được sử dụng trong quá trình ngược lại cho tạo xung điện phản ứng với rung động được áp dụng trên cơ thể của nó. Rung động này có thể ở dạng gõ hoặc đập vào bề mặt của hình tròn.

Thiết lập Arduino và phần tử piezo như trong hình sau

sử dụng piezo làm cảm biến rung với Arduino

const int kPinSensor = A5 const int kPinLed = 13 const int k_threshold = 100 int ledState = LOW // variable used to store the last LED status, to toggle the light void setup() { pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT } void loop() { int val = analogRead(kPinSensor) if (val >= k_threshold) { ledState = !ledState // toggle the value of ledState digitalWrite(kPinLed, ledState) delay(20) // for debouncing } }

Ngưỡng 100 được đưa ra chỉ để đảm bảo rằng Arduino chỉ phản ứng với các rung động thực sự thông qua các lần gõ chứ không phải các rung động nhỏ hơn khác như âm thanh lớn hoặc còi.

Việc lựa chọn chân A5 là không bắt buộc, bạn có thể chọn bất kỳ đầu vào tương tự nào khác theo sở thích của mình và bằng cách khớp với nó trong mã chương trình.

Sử dụng động cơ Servo với Arduino

Động cơ servo là một loại động cơ DC có thể quay đến các góc chính xác theo yêu cầu của một ứng dụng cụ thể. Nó có thể được thực hiện bằng cách áp dụng một lệnh được tính toán cho các đầu vào liên quan của động cơ để tạo ra góc quay hoặc góc quay chính xác trong phạm vi 180 độ trên động cơ.

Thông thường, một động cơ servo có 3 dây hoặc đầu vào. Dây dương thường có màu đỏ, dây âm hoặc dây nối đất có màu đen, dây lệnh hoặc dây tín hiệu thường có màu trắng hoặc vàng.

Arduino hỗ trợ điều khiển động cơ servo thông qua ngôn ngữ hỗ trợ được tích hợp sẵn, giúp điều khiển rất thuận tiện và lý tưởng cho động cơ servo.

Ví dụ sau sẽ cho chúng ta thấy chương trình thiết lập cơ bản để thực hiện điều khiển động cơ servo thông qua Arduino:

Mã được cung cấp dưới đây:

#include Servo servo1 const int kPinPot = A0 const int kPinServo1 = 9 void setup() { servo1.attach(kPinServo1) } void loop() { int val = analogRead(kPinPot) val = map(val, 0, 1023, 0, 180) servo1.write(val) delay(15) }

Chúng ta có thể thấy một vài mục mới ở đây. Một thông báo cho dây đi kèm của servo với chân mà nó được chỉ định. Mã còn lại là mã cung cấp giá trị cho chân từ 0 đến 180, để xác định góc quay trên servo.

Phần kết luận

Chủ đề Arduino có thể dài vô hạn, và do đó nằm ngoài phạm vi của bài viết này. Tuy nhiên, tôi hy vọng hướng dẫn trên chắc chắn sẽ giúp bạn tìm hiểu những kiến thức cơ bản về Arduino và hiểu các thông số quan trọng thông qua các mã ứng dụng ví dụ khác nhau.

Hy vọng rằng nhiều thông tin hơn có thể được cập nhật theo thời gian tại đây, bất cứ khi nào có sẵn.

Trong thời gian chờ đợi, hãy tận hưởng khóa học lập trình của bạn, Chúc bạn vui vẻ với Arduinoing !!

Một cặp: Mạch đồng hồ đo độ cồn sử dụng mô-đun cảm biến MQ-3 Tiếp theo: Mạch nạp chó điều khiển bằng điện thoại di động