Thực đơn
trang chủTrình duyệt

Ngôn ngữ lập trình nào được sử dụng trong Arduino. Ngôn ngữ lập trình Arduino

Giới thiệu

Freeduino/Arduino được lập trình bằng ngôn ngữ lập trình đặc biệt - ngôn ngữ này dựa trên C/C++ và cho phép bạn sử dụng bất kỳ chức năng nào của nó. Nói đúng ra, không có ngôn ngữ Arduino riêng biệt, cũng như không có trình biên dịch Arduino - các chương trình được viết được chuyển đổi (với những thay đổi tối thiểu) thành chương trình trong C/C++, sau đó được biên dịch bởi trình biên dịch AVR-GCC. Vì vậy, trên thực tế, một biến thể của C/C++ chuyên dùng cho bộ vi điều khiển AVR đã được sử dụng.

Sự khác biệt là bạn có được một môi trường phát triển đơn giản và một bộ thư viện cơ bản giúp đơn giản hóa việc truy cập vào các thiết bị ngoại vi nằm “trên” bộ vi điều khiển.

Đồng ý, sẽ rất thuận tiện khi bắt đầu làm việc với cổng nối tiếp ở tốc độ 9600 bit mỗi giây, thực hiện cuộc gọi trên một dòng:

Serial.begin(9600);

Và khi sử dụng C/C++ “trần trụi”, bạn sẽ phải xử lý tài liệu về bộ vi điều khiển và gọi một cái gì đó như thế này:

UBRR0H = ((F_CPU / 16 + 9600 / 2) / 9600 - 1) >> 8;
UBRR0L = ((F_CPU/16 + 9600/2)/9600 - 1);
sbi(UCSR0B, RXEN0);
sbi(UCSR0B, TXEN0);
sbi(UCSR0B, RXCIE0);

Dưới đây là tổng quan ngắn gọn về các chức năng và tính năng chính của lập trình Arduino. Nếu bạn không quen với cú pháp của ngôn ngữ C/C++, chúng tôi khuyên bạn nên tham khảo bất kỳ tài liệu nào về vấn đề này hoặc các nguồn Internet.

Mặt khác, tất cả các ví dụ được trình bày đều rất đơn giản và rất có thể bạn sẽ không gặp bất kỳ khó khăn nào trong việc hiểu văn bản nguồn và viết chương trình của riêng mình ngay cả khi không đọc thêm tài liệu.

Tài liệu đầy đủ hơn (bằng tiếng Anh) được trình bày trên trang web chính thức của dự án - http://www.arduino.cc. Ngoài ra còn có một diễn đàn, liên kết đến các thư viện bổ sung và mô tả của chúng.

Tương tự như mô tả trên trang web chính thức của dự án Arduino, “cổng” dùng để chỉ một điểm tiếp xúc của vi điều khiển được kết nối với một đầu nối theo số tương ứng. Ngoài ra còn có cổng giao tiếp nối tiếp (COM port).

Cấu trúc chương trình

Trong chương trình của bạn, bạn phải khai báo hai hàm chính: setup() và loop().

Hàm setup() được gọi một lần, sau mỗi lần bật nguồn hoặc khởi động lại bo mạch Freeduino. Sử dụng nó để khởi tạo các biến, thiết lập chế độ hoạt động của các cổng kỹ thuật số, v.v.

Hàm loop() thực hiện tuần tự các lệnh được mô tả trong phần thân của nó lặp đi lặp lại. Những thứ kia. Sau khi chức năng hoàn thành, nó sẽ được gọi lại.

Hãy xem một ví dụ đơn giản:

void setup() // cài đặt ban đầu
{
startSerial(9600); // thiết lập tốc độ cổng nối tiếp thành 9600 bps
pinMode(3, INPUT); // thiết lập cổng thứ 3 để nhập dữ liệu
}

// Chương trình kiểm tra cổng thứ 3 xem có tín hiệu trên đó không và gửi phản hồi tới
// dưới dạng tin nhắn văn bản tới cổng nối tiếp của máy tính
void loop() // thân chương trình
{
if (digitalRead(3) == HIGH) // điều kiện để thăm dò cổng thứ 3
serialWrite("H"); // gửi tin nhắn dạng chữ "H" tới cổng COM
khác
serialWrite("L"); // gửi tin nhắn dạng chữ "L" tới cổng COM
độ trễ (1000); // trì hoãn 1 giây.
}

pinMode(cổng, chế độ);

Sự miêu tả:

Định cấu hình cổng được chỉ định để nhập hoặc xuất tín hiệu.

Tùy chọn:

cổng – số cổng có chế độ bạn muốn đặt (giá trị nguyên từ 0 đến 13).

chế độ - INPUT (đầu vào) hoặc OUTPUT (đầu ra).

pinMode(13, OUTPUT); // chân thứ 13 sẽ là đầu ra
pinMode(12, INPUT); // và số 12 là đầu vào

Ghi chú:

Đầu vào analog có thể được sử dụng làm đầu vào/đầu ra kỹ thuật số bằng cách truy cập chúng bằng các số 14 (đầu vào analog 0) đến 19 (đầu vào analog 5)

digitalWrite(port, value);

Sự miêu tả:

Đặt mức điện áp ở mức cao (CAO) hoặc thấp (THẤP) trên cổng được chỉ định.

Tùy chọn:

cổng: số cổng

giá trị: CAO hoặc THẤP

digitalWrite(13, CAO); // đặt chân 13 ở trạng thái “cao”

giá trị = digitalRead(port);

Sự miêu tả:

Đọc giá trị trên cổng được chỉ định

Tùy chọn:

cổng: số cổng được thăm dò

Giá trị trả về: trả về giá trị hiện tại trên cổng (CAO hoặc THẤP) của kiểu int

int giá trị;
val = digitalRead(12); // thăm dò pin thứ 12

Ghi chú:

Nếu không có gì được kết nối với cổng đọc thì hàm digitalRead() có thể trả về giá trị CAO hoặc THẤP một cách thất thường.

Đầu vào/đầu ra tín hiệu tương tự

giá trị = analogRead(port);

Sự miêu tả:

Đọc một giá trị từ cổng analog được chỉ định. Freeduino chứa 6 kênh, bộ chuyển đổi tương tự sang số, mỗi kênh 10 bit. Điều này có nghĩa là điện áp đầu vào từ 0 đến 5V được chuyển đổi thành giá trị nguyên từ 0 đến 1023. Độ phân giải đọc ra là: 5V/1024 giá trị = 0,004883 V/giá trị (4,883 mV). Cần khoảng 100 nS (0,0001 C) để đọc giá trị đầu vào tương tự, do đó tốc độ đọc tối đa là khoảng 10.000 lần mỗi giây.

Tùy chọn:

Giá trị trả về: Trả về một số int trong phạm vi từ 0 đến 1023 được đọc từ cổng được chỉ định.

int giá trị;
val = analogRead(0); // đọc giá trị ở đầu vào analog thứ 0

Ghi chú:

Cổng analog được xác định là đầu vào tín hiệu theo mặc định và không giống như cổng kỹ thuật số, không cần phải cấu hình bằng cách gọi hàm pinMode.

analogWrite(port, value);

Sự miêu tả:

Xuất một giá trị tương tự tới cổng. Chức năng này hoạt động trên: 3, 5, 6, 9, 10 và 11 cổng kỹ thuật số Freeduino.

Có thể được sử dụng để thay đổi độ sáng của đèn LED, điều khiển động cơ, v.v. Sau khi gọi hàm analogWrite, cổng tương ứng bắt đầu hoạt động ở chế độ điều chế độ rộng xung điện áp cho đến khi có một lệnh gọi khác đến hàm analogWrite (hoặc các chức năng DigitalRead/digitalWrite trên cùng một cổng).

Tùy chọn:

cổng: số lượng đầu vào tương tự đang được thăm dò

giá trị: một số nguyên từ 0 đến 255. Giá trị 0 tạo ra 0 V trên cổng được chỉ định; giá trị 255 tạo ra +5V trên cổng được chỉ định. Đối với các giá trị từ 0 đến 255, cổng bắt đầu thay đổi nhanh chóng giữa các mức điện áp 0 và +5 V - giá trị càng cao thì cổng tạo ra mức CAO (5 V) càng thường xuyên.

analogWrite(9, 128); // đặt chân 9 thành giá trị tương đương 2,5V

Ghi chú:

Không cần gọi pinMode để đặt cổng thành tín hiệu đầu ra trước khi gọi analogWrite.

Tần số tạo tín hiệu là khoảng 490 Hz.

thời gian = milis();

Sự miêu tả:

Trả về số mili giây kể từ khi Freeduino thực hiện chương trình hiện tại. Bộ đếm sẽ tràn và đặt lại sau khoảng 9 giờ.

Giá trị trả về: trả về giá trị dài không dấu

chưa ký từ lâu; // khai báo một biến thời gian có kiểu unsigned long
thời gian = milis(); // chuyển số mili giây

độ trễ (time_ms);

Sự miêu tả:

Tạm dừng chương trình trong số mili giây được chỉ định.

Tùy chọn:

time_ms - thời gian trễ chương trình tính bằng mili giây

độ trễ (1000); // tạm dừng 1 giây

độ trễ micro giây

độ trễMicro giây(time_μs);

Sự miêu tả:

Tạm dừng chương trình trong số micro giây được chỉ định.

Tùy chọn:

time_μs – thời gian trễ chương trình tính bằng micro giây

độ trễMicro giây(500); // tạm dừng 500 micro giây

xungIn(cổng, giá trị);

Sự miêu tả:

Đọc xung (cao hoặc thấp) từ cổng kỹ thuật số và trả về thời lượng xung tính bằng micro giây.

Ví dụ: nếu tham số "giá trị" được đặt thành CAO khi gọi hàm thì PulseIn() sẽ đợi mức tín hiệu cao đến cổng. Kể từ thời điểm nó đến, quá trình đếm ngược bắt đầu cho đến khi nhận được mức tín hiệu thấp tại cổng. Hàm trả về độ dài xung (mức cao) tính bằng micro giây. Hoạt động với các xung từ 10 micro giây đến 3 phút. Lưu ý rằng chức năng này sẽ không trả về kết quả cho đến khi phát hiện thấy xung.

Tùy chọn:

cổng: số cổng mà chúng ta đọc xung

giá trị: loại xung CAO hoặc THẤP

Giá trị trả về: trả về thời lượng xung tính bằng micro giây (kiểu int)

thời lượng int; // khai báo biến thời lượng kiểu int
thời lượng = xungIn (pin, CAO); // đo độ dài xung

Truyền dữ liệu nối tiếp

Freeduino có bộ điều khiển tích hợp để truyền dữ liệu nối tiếp, có thể được sử dụng để liên lạc giữa các thiết bị Freeduino/Arduino và để liên lạc với máy tính. Trên máy tính, kết nối tương ứng được thể hiện bằng cổng USB COM.

Giao tiếp diễn ra qua các cổng kỹ thuật số 0 và 1 và do đó bạn sẽ không thể sử dụng chúng cho I/O kỹ thuật số nếu bạn đang sử dụng các chức năng nối tiếp.

Serial.begin(baud_rate);

Sự miêu tả:

Đặt tốc độ truyền thông tin cổng COM tính bằng bit trên giây để truyền dữ liệu nối tiếp. Để giao tiếp với máy tính, hãy sử dụng một trong các tốc độ tiêu chuẩn sau: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 hoặc 115200. Bạn cũng có thể xác định các tốc độ khác khi giao tiếp với bộ vi điều khiển khác bằng cách cổng 0 và 1.

Tùy chọn:

baud_rate: Tốc độ luồng dữ liệu tính bằng bit trên giây.

Serial.begin(9600); // đặt tốc độ thành 9600 bps

Nối tiếp.có sẵn

count = Serial.available();

Sự miêu tả:

Các byte nhận được qua cổng nối tiếp sẽ được đưa vào bộ đệm của vi điều khiển, từ đó chương trình của bạn có thể đọc chúng. Hàm trả về số byte tích lũy trong bộ đệm. Bộ đệm nối tiếp có thể lưu trữ tới 128 byte.

Giá trị trả về:

Trả về giá trị int - số byte có sẵn để đọc trong bộ đệm nối tiếp hoặc 0 nếu không có sẵn.

if (Serial.available() > 0) ( // Nếu có dữ liệu trong bộ đệm
// cần có nơi tiếp nhận và xử lý dữ liệu ở đây
}

char = Serial.read();

Sự miêu tả:

Đọc byte tiếp theo từ bộ đệm cổng nối tiếp.

Giá trị trả về:

Byte dữ liệu đến đầu tiên có sẵn từ cổng nối tiếp hoặc -1 nếu không có dữ liệu đến.

incomingByte = Serial.read(); // đọc byte

Sự miêu tả:

Xóa bộ đệm đầu vào cổng nối tiếp. Dữ liệu trong bộ đệm sẽ bị mất và các lệnh gọi tiếp theo tới Serial.read() hoặc Serial.available() sẽ có ý nghĩa đối với dữ liệu nhận được sau lệnh gọi Serial.flush().

Serial.flush(); // Xóa bộ đệm - bắt đầu nhận dữ liệu “từ đầu”

Sự miêu tả:

Xuất dữ liệu ra cổng nối tiếp.

Tùy chọn:

Hàm này có một số biểu mẫu cuộc gọi tùy thuộc vào loại và định dạng của dữ liệu đầu ra.

Serial.print(b, DEC) in một chuỗi ASCII - biểu diễn thập phân của b.

int b = 79;

Serial.print(b, HEX) in một chuỗi ASCII - biểu diễn thập lục phân của số b.

int b = 79;

Serial.print(b, OCT) in một chuỗi ASCII - biểu diễn bát phân của số b.

int b = 79;
Serial.print(b, OCT); // sẽ xuất chuỗi “117” ra cổng

Serial.print(b, BIN) in một chuỗi ASCII - biểu diễn nhị phân của số b.

int b = 79;
Serial.print(b, BIN); // sẽ xuất chuỗi “1001111” ra cổng

Serial.print(b, BYTE) in byte thấp của b.

int b = 79;
Serial.print(b, BYTE); // sẽ hiển thị số 79 (một byte). Trong màn hình
// từ cổng nối tiếp, chúng ta nhận được ký hiệu “O” - nó
// mã là 79

Serial.print(str) nếu str là một chuỗi hoặc mảng ký tự, gửi str tới byte byte cổng COM.

byte char = (79, 80, 81); // mảng 3 byte có giá trị 79,80,81
Serial.print("Đây là byte của chúng tôi:"); //xuất ra dòng “Đây là byte của chúng tôi:”
Serial.print(byte); //xuất ra 3 ký tự với mã 79,80,81 –
// đây là các ký tự "OPQ"

Serial.print(b) nếu b thuộc loại byte hoặc char, hãy in số b đó ra cổng.

ký tự b = 79;
Serial.print(b); // sẽ xuất ký tự “O” ra cổng

Serial.print(b) nếu b có kiểu số nguyên, in biểu diễn thập phân của b ra cổng.

int b = 79;
Serial.print(b); // sẽ xuất chuỗi “79” ra cổng

Sự miêu tả:

Hàm Serial.println tương tự như hàm Serial.print và có cùng các tùy chọn gọi. Sự khác biệt duy nhất là hai ký tự bổ sung được xuất ra sau dữ liệu - ký tự trả về đầu dòng (ASCII 13 hoặc "\r") và ký tự dòng mới (ASCII 10 hoặc "\n").

Ví dụ 1 và ví dụ 2 sẽ xuất ra cổng tương tự:

int b = 79;
Serial.print(b, DEC); // sẽ xuất chuỗi “79” ra cổng
Serial.print("\r\n"); // sẽ hiển thị các ký tự "\r\n" – nguồn cấp dữ liệu
Serial.print(b, HEX); // sẽ xuất chuỗi “4F” ra cổng
Serial.print("\r\n");//sẽ in các ký tự "\r\n" – nguồn cấp dữ liệu

int b = 79;
Serial.println(b, DEC); // sẽ xuất chuỗi “79\r\n” ra cổng
Serial.println(b, HEX); // sẽ xuất chuỗi “4F\r\n” ra cổng

Trong màn hình cổng nối tiếp, chúng tôi nhận được.

Nền tảng ngôn ngữ lập trình của mô-đun Arduino là ngôn ngữ C (rất có thể là C++). Chính xác hơn, phương ngữ này được gọi là Xử lý/Kết nối. Bạn sẽ tìm thấy một cái nhìn tổng quan tốt về ngôn ngữ trong phần phụ lục. Nhưng tôi muốn nói nhiều hơn không phải về ngôn ngữ mà là về lập trình.

Chương trình là một tập hợp các lệnh nhất định được hiểu bởi bộ xử lý, bộ xử lý của máy tính của bạn hoặc bộ xử lý vi điều khiển của mô-đun Arduino, điều đó không thành vấn đề. Bộ xử lý đọc hướng dẫn và thực hiện chúng. Bất kỳ lệnh nào mà bộ xử lý hiểu đều là số nhị phân. Đây chỉ là số nhị phân và không có gì khác. Bằng cách thực hiện các phép tính số học mà bộ xử lý từng được thiết kế để thực hiện, bộ xử lý hoạt động trên các con số. Số nhị phân. Và hóa ra cả các lệnh và những gì chúng đề cập đến đều chỉ là số nhị phân. Như thế này. Nhưng làm thế nào bộ xử lý có thể sắp xếp “đống” số nhị phân này?

Đầu tiên, tất cả các số nhị phân này được ghi vào các ô RAM liên tiếp có địa chỉ. Khi bạn tải một chương trình và nó bắt đầu chạy, bộ xử lý sẽ nhận được địa chỉ đầu tiên của chương trình, nơi lệnh phải được viết. Những lệnh yêu cầu bộ xử lý hoạt động với các số đều có “dấu nhận dạng”, chẳng hạn như trong hai ô nhớ tiếp theo có hai số cần được thêm vào. Và bộ đếm, hãy gọi nó là bộ đếm chương trình, nơi ghi địa chỉ của lệnh tiếp theo, trong trường hợp này sẽ tăng địa chỉ để chương trình sẽ chứa lệnh tiếp theo tại địa chỉ này. Nếu chương trình không hoạt động chính xác hoặc có lỗi, bộ xử lý có thể mắc lỗi và sau đó, khi đọc một số thay vì lệnh, bộ xử lý sẽ thực hiện điều gì đó hoàn toàn khác với những gì nó nên làm và chương trình “đóng băng”.

Vì vậy, bất kỳ chương trình nào cũng là một chuỗi các số nhị phân. Và lập trình là khả năng viết đúng các chuỗi số nhị phân. Cách đây khá lâu, các công cụ đặc biệt gọi là ngôn ngữ lập trình đã bắt đầu được sử dụng để viết chương trình.

Tuy nhiên, bất kỳ chương trình nào trước tiên đều yêu cầu bạn phải hiểu rõ chương trình đó phải làm gì và tại sao lại cần thiết. Bạn càng hiểu rõ điều này thì việc tạo chương trình càng dễ dàng hơn. Các chương trình nhỏ, tuy khó có thể nói chương trình nào nhỏ, chương trình nào không, nhưng có thể coi là một tổng thể. Các chương trình phức tạp hơn tốt nhất nên chia thành các phần có thể được coi là các chương trình độc lập. Bằng cách này, tốt hơn là tạo chúng, dễ dàng gỡ lỗi và kiểm tra hơn.

Tôi chưa sẵn sàng tranh luận, nhưng tôi nghĩ sẽ thuận tiện hơn khi bắt đầu một chương trình với phần mô tả bằng ngôn ngữ thông thường. Và theo nghĩa này, tôi tin rằng không nên nhầm lẫn việc lập trình với việc viết mã chương trình. Khi một chương trình được mô tả bằng các từ thông thường, bạn sẽ dễ dàng xác định hơn, chẳng hạn như nên chọn ngôn ngữ lập trình nào để tạo mã chương trình.

Cách gần nhất để viết chương trình sử dụng số nhị phân là hợp ngữ. Nó được đặc trưng bởi sự tương ứng của các lệnh ngôn ngữ với các lệnh nhị phân được bộ xử lý hiểu. Nhưng các chương trình viết mã bằng hợp ngữ đòi hỏi nhiều nỗ lực và gần với nghệ thuật hơn là các thao tác hình thức. Các ngôn ngữ cấp cao như BASIC hoặc C phổ biến hơn và dễ sử dụng hơn. Và từ lâu, ngôn ngữ đồ họa đã được sử dụng để viết chương trình ở dạng tổng quát và gần đây đã xuất hiện những “trình dịch” từ ngôn ngữ này sang ngôn ngữ của bộ xử lý.

Ngoài các ngôn ngữ lập trình chung, luôn có một số ngôn ngữ lập trình chuyên môn hóa và có những ngôn ngữ chuyên biệt. Tôi cũng sẽ bao gồm ngôn ngữ lập trình của mô-đun Arduino trong số ngôn ngữ sau.

Mọi thứ chúng ta cần để yêu cầu mô-đun thực hiện điều gì đó chúng ta cần đều được sắp xếp thành một bộ lệnh thuận tiện. Nhưng trước tiên, chúng ta cần gì ở Arduino?

Mô-đun này có thể được sử dụng với nhiều công suất khác nhau - nó là trái tim (hoặc đầu) của robot, nó là nền tảng của thiết bị, nó cũng là một công cụ xây dựng thuận tiện để làm chủ công việc với bộ vi điều khiển, v.v.

Ở trên, chúng tôi đã sử dụng các chương trình đơn giản để kiểm tra kết nối của mô-đun với máy tính. Đối với một số người, chúng có vẻ quá đơn giản và do đó không thú vị, nhưng bất kỳ chương trình phức tạp nào cũng bao gồm các đoạn đơn giản hơn, tương tự như những chương trình mà chúng ta đã làm quen.

Hãy xem chương trình đơn giản nhất “Blink an LED” có thể cho chúng ta biết điều gì.

int ledPin = 13;

pinMode(ledPin, OUTPUT);

digitalWrite(ledPin, CAO);

digitalWrite(ledPin, THẤP);

Đầu tiên, chúng ta hãy nhớ đèn LED là gì. Về bản chất, đây là một diode thông thường, do thiết kế của nó, khi dòng điện chạy theo hướng thuận, điểm nối bắt đầu phát sáng. Nghĩa là, để đèn LED phát sáng, dòng điện phải chạy qua nó, nghĩa là phải đặt điện áp vào đèn LED. Và để dòng điện không vượt quá giá trị cho phép, một điện trở phải mắc nối tiếp với đèn LED, gọi là điện trở giới hạn dòng điện (xem Phụ lục A, đầu ra kỹ thuật số). Điện áp được đưa vào đèn LED bởi bộ vi điều khiển tạo thành nền tảng của mô-đun Arduino. Bộ vi điều khiển, ngoài bộ xử lý thực thi các lệnh của chúng ta, còn có một hoặc nhiều cổng I/O. Không cần xem xét thiết bị cụ thể của cổng, hãy nói điều này - khi chân cổng hoạt động như một đầu ra, nó có thể được biểu diễn dưới dạng đầu ra của một vi mạch kỹ thuật số với hai trạng thái bật và tắt (có điện áp ở đầu ra , không có điện áp ở đầu ra).

Nhưng chân cổng tương tự cũng có thể hoạt động như một đầu vào. Trong trường hợp này, nó có thể được biểu diễn, chẳng hạn như đầu vào của vi mạch kỹ thuật số - mức logic, cao hoặc thấp, được áp dụng cho đầu vào (xem Phụ lục A, đầu vào kỹ thuật số).

Cách chúng tôi nháy đèn LED:

Kích hoạt pin đầu ra cổng. Tắt đầu ra cổng.

Nhưng bộ xử lý rất nhanh. Chúng ta sẽ không có thời gian để ý đến sự nhấp nháy. Để nhận thấy sự nhấp nháy này, chúng ta cần thêm các khoảng dừng. Đó là:

Kích hoạt pin đầu ra cổng. Tạm dừng 1 giây.

Tắt đầu ra cổng.

Tạm dừng 1 giây.

Đây là chương trình của chúng tôi. Bộ xử lý sẽ đọc lệnh đầu tiên và bật đầu ra, đèn LED sẽ sáng lên. Sau đó bộ xử lý sẽ tạm dừng và tắt đầu ra, đèn LED sẽ tắt. Nhưng anh chỉ chớp mắt một lần.

Sự lặp lại của một quy trình hoặc tập lệnh được gọi là vòng lặp trong lập trình. Các loại chu kỳ khác nhau được sử dụng. Có một vòng lặp chạy một số lần nhất định. Đây là một vòng lặp for. Có các vòng lặp chạy cho đến khi đáp ứng một số điều kiện, là một phần của cấu trúc vòng lặp trong ngôn ngữ. Và nếu điều kiện không bao giờ được đáp ứng thì vòng lặp sẽ được thực hiện vô số lần. Đó là một chu kỳ vô tận.

Tôi không nghĩ bộ vi điều khiển được sử dụng với các chương trình thuộc loại được hiển thị ở trên. Nghĩa là, một số lệnh được thực thi một lần và bộ điều khiển không còn hoạt động. Theo quy định, nó hoạt động liên tục ngay khi có điện áp cung cấp vào nó. Điều này có nghĩa là bộ vi điều khiển phải hoạt động theo một vòng lặp vô tận.

Đây chính xác là những gì hàm void loop() nói, vòng lặp là một vòng lặp, một vòng lặp khép kín. Không có điều kiện để dừng chu trình, và do đó, không có điều kiện để hoàn thành nó.

Ngoài ra, chúng ta phải cho mô-đun Arduino biết chúng ta muốn sử dụng chân cổng nào và cách chúng ta muốn sử dụng nó, cho đầu ra (OUTPUT) hoặc cho đầu vào (INPUT). Mục đích này được phục vụ bởi hàm void setup(), chức năng này bắt buộc đối với ngôn ngữ Arduino, ngay cả khi nó không được sử dụng và lệnh pinMode() để đặt chế độ vận hành đầu ra.

pinMode(ledPin, OUTPUT);

Chưa hết, cấu trúc ngôn ngữ sử dụng các biến để xác định số đầu ra:

int ledPin = 13;

Sử dụng các biến là thuận tiện. Nếu bạn quyết định sử dụng đầu ra 12 thay vì 13, bạn sẽ chỉ thực hiện thay đổi trên một dòng. Điều này đặc biệt đúng trong các chương trình lớn. Tên biến có thể chọn theo ý muốn nhưng nhìn chung chỉ phải là ký tự và số lượng ký tự thường bị giới hạn. Nếu bạn đặt tên biến không chính xác, tôi nghĩ trình biên dịch sẽ sửa cho bạn.

Hàm digitalWrite(ledPin, HIGH) đặt chân được chỉ định ở trạng thái cao, nghĩa là bật chân này.

Và độ trễ (1000), như bạn đã hiểu, có nghĩa là tạm dừng 1000 mili giây hoặc 1 giây.

Vẫn còn phải hiểu các tiền tố như int và void có nghĩa là gì. Mọi giá trị, mọi biến đều được đặt trong bộ nhớ, cũng như các lệnh chương trình. Các số thường bao gồm 8 bit được ghi vào các ô nhớ. Đây là một byte. Nhưng một byte là một số từ 0 đến 255. Để ghi các số lớn, bạn cần hai byte trở lên, tức là hai ô nhớ trở lên. Để bộ xử lý hiểu rõ cách tìm một số, các loại số khác nhau có tên khác nhau. Vì vậy, một số gọi là byte sẽ chiếm một ô, int (số nguyên, số nguyên) sẽ chiếm nhiều hơn. Ngoài ra, các hàm sử dụng trong ngôn ngữ lập trình cũng trả về số. Để xác định loại số mà hàm sẽ trả về, hãy viết loại số trả về đó trước hàm. Nhưng một số hàm có thể không trả về số; các hàm đó có ký hiệu void đứng trước (xem Phụ lục A, các biến).

Đó là điều thú vị mà ngay cả chương trình đơn giản nhất cũng có thể kể ra.

Tôi hy vọng bạn có thể đọc về tất cả những điều này trong phần phụ lục. Bây giờ chúng ta hãy thực hiện những thí nghiệm đơn giản, chỉ sử dụng những gì chúng ta đã biết về khả năng của ngôn ngữ. Đầu tiên, hãy thay thế một biến kiểu int, biến này chiếm nhiều dung lượng bộ nhớ, bằng một byte - một khoảng trắng, một ô nhớ. Hãy xem chúng ta có thể làm gì.

byte ledPin = 13;

pinMode(ledPin, OUTPUT);

digitalWrite(ledPin, CAO);

digitalWrite(ledPin, THẤP);

Sau khi biên dịch và nạp chương trình vào module, chúng ta sẽ không nhận thấy bất kỳ thay đổi nào trong quá trình hoạt động của chương trình. Khỏe. Sau đó chúng ta sẽ thay đổi chương trình để nhận thấy những thay đổi trong hoạt động của nó.

Để làm điều này, chúng ta sẽ thay thế số trong hàm trễ (1000) bằng một biến, gọi nó là my_del. Biến này phải là một số nguyên, tức là int.

int my_del = 5000;

Hãy nhớ kết thúc mỗi lệnh bằng dấu chấm phẩy. Thực hiện các thay đổi đối với chương trình, biên dịch và tải nó vào mô-đun. Sau đó thay đổi biến và biên dịch lại và tải lại:

byte my_del = 5000;

Tôi chắc chắn sự khác biệt sẽ được chú ý.

Hãy thực hiện một thử nghiệm khác với việc thay đổi thời lượng tạm dừng. Hãy giảm thời gian tạm dừng, chẳng hạn, năm lần. Hãy tạm dừng trong 2 giây, sau đó tăng lên gấp năm lần. Và một lần nữa chúng tôi tạm dừng trong 2 giây. Một vòng lặp chạy một số lần xác định được gọi là vòng lặp for và được viết như sau:

vì (int i = 0; tôi<5; i++)

một cái gì đó được thực thi trong vòng lặp for

Để thực hiện vòng lặp, nó cần một biến, đối với chúng ta đó là i, biến đó cần được gán một giá trị ban đầu mà chúng ta đã gán cho nó. Sau đó tuân theo điều kiện kết thúc vòng lặp, chúng ta có i nhỏ hơn 5. Và mục nhập i++ là một mục nhập ngôn ngữ C điển hình để tăng một biến lên một. Dấu ngoặc nhọn giới hạn tập lệnh có thể được thực thi trong vòng lặp for. Các ngôn ngữ lập trình khác có thể có các dấu phân cách khác nhau để làm nổi bật một khối mã chức năng.

Bên trong vòng lặp, chúng ta thực hiện tương tự như trước, với một vài thay đổi nhỏ:

vì (int i = 0; tôi<5; i++)

digitalWrite(ledPin, CAO);

digitalWrite(ledPin, THẤP);

my_del = my_del - 100;

Chúng ta đã nói về việc thay đổi bản ghi tạm dừng ở trên và việc thay đổi bản ghi tạm dừng có thể đạt được bằng cách giảm biến đi 100.

Đối với vòng lặp thứ hai, chúng ta sẽ viết cùng một khối mã, nhưng chúng ta sẽ tăng biến thời lượng tạm dừng lên 100.

vì (int i = 0; tôi<5; i++)

digitalWrite(ledPin, CAO);

digitalWrite(ledPin, THẤP);

Bạn nhận thấy rằng việc ghi lại mức giảm tạm dừng và mức tăng tạm dừng trông khác nhau. Đây cũng là một tính năng của ngôn ngữ C. Mặc dù, để rõ ràng, mục này lẽ ra phải được lặp lại, chỉ thay đổi dấu trừ thành dấu cộng. Vì vậy, chúng tôi nhận được chương trình này:

int ledPin = 13;

int my_del = 1000;

pinMode(ledPin, OUTPUT);

vì (int i = 0; tôi<5; i++)

digitalWrite(ledPin, CAO);

digitalWrite(ledPin, THẤP);

vì (int i = 0; tôi<5; i++)

digitalWrite(ledPin, CAO);

digitalWrite(ledPin, THẤP);

Hãy sao chép mã chương trình của chúng tôi vào chương trình Arduin, biên dịch và tải mã vào mô-đun. Sự thay đổi về thời gian tạm dừng là đáng chú ý. Và nó sẽ còn đáng chú ý hơn nữa, hãy thử nếu vòng lặp for được thực thi, chẳng hạn như 8 lần.

Những gì chúng ta vừa làm cũng giống như những gì các lập trình viên chuyên nghiệp làm - có một chương trình làm sẵn, có thể dễ dàng sửa đổi cho phù hợp với nhu cầu hoặc mong muốn của bạn. Vì vậy, họ lưu trữ tất cả các chương trình của họ. Điều tôi khuyên bạn cũng nên làm.

Chúng ta đã bỏ lỡ điều gì trong thí nghiệm của mình? Chúng tôi chưa bình luận về công việc của chúng tôi. Để thêm nhận xét, hãy sử dụng dấu gạch chéo kép hoặc dấu gạch chéo đơn nhưng có dấu hoa thị (xem Phụ lục A). Tôi khuyên bạn nên tự làm việc này, vì sau một thời gian, khi quay lại chương trình, bạn sẽ hiểu nó dễ dàng hơn nếu có lời giải thích về những gì bạn đang làm ở vị trí này hoặc vị trí kia của chương trình. Và tôi cũng khuyên bạn nên lưu trữ mô tả của nó bằng ngôn ngữ đơn giản, được thực hiện bằng bất kỳ trình soạn thảo văn bản nào, trong thư mục chứa mỗi chương trình.

Chương trình đơn giản nhất “nháy đèn LED” có thể phục vụ cho hàng tá thử nghiệm nữa (ngay cả với một đèn LED). Đối với tôi, có vẻ như phần này của công việc, nghĩ ra những gì khác có thể làm được một cách thú vị, là phần thú vị nhất. Nếu bạn tham khảo phần phụ lục mô tả ngôn ngữ lập trình, đến phần “điều khiển chương trình”, bạn có thể thay thế vòng lặp for bằng một loại vòng lặp khác. Và thử xem các loại chu trình khác hoạt động như thế nào.

Mặc dù bộ xử lý vi điều khiển, giống như bất kỳ bộ xử lý nào khác, có thể thực hiện các phép tính (đó là lý do tại sao nó được phát minh) và điều này được sử dụng, chẳng hạn như trong các thiết bị, hoạt động điển hình nhất đối với vi điều khiển sẽ là đặt đầu ra cổng ở mức cao hoặc thấp. trạng thái, tức là “đèn LED nhấp nháy” như một phản ứng với các sự kiện bên ngoài.

Bộ vi điều khiển tìm hiểu về các sự kiện bên ngoài chủ yếu dựa vào trạng thái của các đầu vào. Bằng cách đặt các chân cổng thành đầu vào kỹ thuật số, chúng ta có thể giám sát nó. Nếu trạng thái ban đầu của đầu vào ở mức cao và một sự kiện khiến đầu vào ở mức thấp thì chúng ta có thể thực hiện điều gì đó để phản hồi lại sự kiện đó.

Ví dụ đơn giản nhất là một nút ở đầu vào. Khi không nhấn nút, đầu vào ở trạng thái cao. Nếu chúng ta nhấn nút, đầu vào sẽ ở mức thấp và chúng ta có thể “bật sáng” đèn LED ở đầu ra. Lần tiếp theo bạn nhấn nút, đèn LED có thể tắt.

Đây lại là một ví dụ về một chương trình đơn giản. Ngay cả người mới bắt đầu cũng có thể thấy nó không thú vị. Tuy nhiên, chương trình đơn giản này cũng có thể tìm thấy những ứng dụng khá hữu ích. Tôi sẽ chỉ đưa ra một ví dụ: sau khi nhấn nút, đèn LED sẽ không sáng mà sẽ nhấp nháy (theo một cách nhất định). Và hãy lấy một đèn LED có bức xạ hồng ngoại. Kết quả là chúng ta sẽ có được một bảng điều khiển. Đây là một chương trình đơn giản như vậy.

Có sự khác biệt trong danh sách ví dụ ở các phiên bản khác nhau của chương trình. Nhưng bạn có thể tham khảo hướng dẫn sử dụng ngôn ngữ trong phần phụ lục, trong đó có ví dụ và sơ đồ chương trình (trong phần ví dụ được gọi là "phụ lục") để làm việc với đầu vào. Tôi sẽ sao chép chương trình:

int ledPin = 13;

pinMode(ledPin, OUTPUT);

pinMode(inPin, INPUT);

if (digitalRead(inPin) == CAO)

digitalWrite(ledPin, CAO);

digitalWrite(ledPin, THẤP);

Và như bạn có thể thấy, chúng ta có được một chương trình hoàn toàn mới bằng cách sửa đổi chương trình cũ. Bây giờ đèn LED sẽ chỉ nhấp nháy khi nhấn nút kết nối với chân 2. Chân 2 được kết nối với dây chung (mặt đất, GND) thông qua điện trở 10 kOhm. Nút này được kết nối ở một đầu với điện áp nguồn + 5V và ở đầu còn lại với chân 2.

Trong chương trình, chúng ta gặp phải một cấu trúc ngôn ngữ mới từ phần điều khiển chương trình. Nó đọc như thế này: nếu điều kiện (được đặt trong ngoặc) được đáp ứng thì khối chương trình được đặt trong dấu ngoặc nhọn sẽ được thực thi. Lưu ý rằng trong điều kiện (digitalRead(inPin) == CAO), sự bằng nhau của đầu vào ở trạng thái cao được thực hiện bằng cách sử dụng hai dấu bằng! Rất thường xuyên, vội vàng, điều này bị lãng quên và điều kiện hóa ra không chính xác.

Chương trình có thể được sao chép và tải vào mô-đun Arduino. Tuy nhiên, để kiểm tra hoạt động của chương trình, bạn sẽ cần thực hiện một số thay đổi đối với thiết kế mô-đun. Tuy nhiên, điều này phụ thuộc vào loại mô-đun. Mô-đun ban đầu có ổ cắm để kết nối với thẻ mở rộng. Trong trường hợp này, bạn có thể chèn dây đặc phù hợp vào những vị trí cần thiết trong đầu nối. Mô-đun của tôi có các điểm tiếp xúc dạng lưỡi để kết nối với bảng mở rộng. Tôi có thể tìm một đầu nối phù hợp hoặc rẻ hơn là sử dụng ổ cắm phù hợp cho chip trong gói DIP.

Câu hỏi thứ hai là làm thế nào để tìm ra các chân module được sử dụng trong chương trình?

Hình ảnh tôi chụp từ trang web: http://robocraft.ru/ sẽ giúp bạn tìm ra điều này.

Cơm. 4.1. Vị trí và mục đích của bộ điều khiển và các chân mô-đun Arduino

Tất cả các chân trên mô-đun CraftDuino của tôi đều được dán nhãn nên việc tìm đúng chân rất dễ dàng. Bạn có thể kết nối một nút và một điện trở và kiểm tra hoạt động của chương trình. Nhân tiện, trên trang web RoboCraft nêu trên, toàn bộ quá trình được hiển thị bằng hình ảnh (nhưng chương trình không sử dụng các kết luận giống hệt nhau!). Tôi khuyên bạn nên xem xét.

Nhiều bộ vi điều khiển bao gồm các thiết bị phần cứng bổ sung. Vì vậy, Atmega168, trên cơ sở lắp ráp mô-đun Arduino, có UART, một bộ phận tích hợp để liên lạc với các thiết bị khác bằng cách sử dụng trao đổi dữ liệu nối tiếp. Ví dụ: với máy tính qua cổng COM. Hoặc với một bộ vi điều khiển khác sử dụng khối UART tích hợp của nó. Ngoài ra còn có một bộ chuyển đổi analog sang kỹ thuật số. Và một máy định hình điều chế độ rộng xung.

Việc sử dụng cái sau được minh họa bằng một chương trình mà tôi cũng sẽ sao chép từ trang web RoboCraft. Nhưng chương trình cũng có thể được lấy từ ứng dụng. Và có lẽ nó có trong các ví dụ về chương trình Arduino.

// Đèn LED mờ dần của BARRAGAN

giá trị int = 0; // biến để lưu trữ giá trị mong muốn

int ledpin = 9; // LED kết nối với chân số 9

// Không cần gọi hàm pinMode

for(value = 0 ; giá trị<= 255; value+=5) // постепенно зажигаем светодиод

analogWrite(ledpin, value); // giá trị đầu ra (từ 0 đến 255)

độ trễ(30); // chờ đợi 🙂

for(value = 255; value >=0; value-=5) // tắt dần đèn LED

analogWrite(ledpin, value);

Nếu trong chương trình trước, hàm digitalRead(inPin), đọc đầu vào kỹ thuật số, là mới đối với chúng ta, thì trong chương trình này, hàm analogWrite(ledpin, value) cũng mới đối với chúng ta, mặc dù các tham số của hàm này là các biến đã quen thuộc với chúng ta . Chúng ta sẽ nói về việc sử dụng đầu vào tương tự, sử dụng bộ ADC (bộ chuyển đổi tương tự sang số) sau. Bây giờ chúng ta hãy quay lại vấn đề lập trình chung.

Lập trình là việc mà ai cũng có thể làm được nhưng sẽ cần có thời gian để thành thạo cả lập trình và bất kỳ ngôn ngữ lập trình nào. Ngày nay có một số chương trình giúp bạn thành thạo lập trình. Và một trong số đó có liên quan trực tiếp đến mô-đun Arduino. Nó được gọi là Scratch for Arduino hay gọi tắt là S4A. Bạn có thể tìm và tải xuống chương trình này tại: http://seaside.citilab.eu/scratch/arduino. Tôi không biết chính xác tên của chương trình được dịch như thế nào, nhưng “bắt đầu từ đầu” được dịch là “bắt đầu từ đầu”.

Trang web của dự án S4A có các phiên bản dành cho Windows và Linux, nhưng đối với hệ điều hành sau, chương trình đã sẵn sàng để cài đặt trong phiên bản phân phối Debian. Tôi không muốn nói rằng nó không thể được sử dụng với các bản phân phối Linux khác, nhưng trước tiên chúng ta sẽ xem cách hoạt động với mô-đun Arduino trong Windows.

Sau khi cài đặt chương trình theo cách thông thường, bạn có thể định cấu hình giao diện sang tiếng Nga bằng cách sử dụng chuyển đổi ngôn ngữ.

Cơm. 4.2. Chuyển đổi ngôn ngữ giao diện chương trình

Biểu tượng thanh công cụ đầu tiên khi được nhấp vào sẽ hiển thị tất cả các ngôn ngữ có thể có của giao diện chương trình. Ngôn ngữ tiếng Nga có thể được tìm thấy trong phần...

Cơm. 4.3. Danh sách ngôn ngữ sử dụng trong giao diện chương trình

... được đánh dấu là "thêm...".

Nếu bạn không làm gì thì dòng chữ ở cửa sổ bên phải “Bảng tìm kiếm…” vẫn còn nhưng không tìm thấy mô-đun. Để kết nối mô-đun Arduino với chương trình S4A, bạn cần tải xuống thứ khác từ trang web của dự án.

Cơm. 4.4. Tệp để tải lên mô-đun Arduino cho S4A

Tập tin này không gì khác hơn là một chương trình dành cho Arduino (Sketch). Tức là một tệp văn bản có thể được sao chép vào trình soạn thảo Arduino, được biên dịch và tải vào mô-đun. Sau khi thoát khỏi chương trình Arduino, bạn có thể chạy chương trình S4A và mô-đun hiện đã được định vị.

Cơm. 4.5. Kết nối module với chương trình

Đầu vào analog của mô-đun không được kết nối, đầu vào kỹ thuật số cũng không được kết nối, do đó các giá trị hiển thị cho mô-đun liên tục thay đổi một cách ngẫu nhiên.

Sau khi làm quen với các thành phần cơ bản của Arduino, cũng như viết chương trình “Hello World!”. Đã đến lúc làm quen với một ngôn ngữ lập trình.

Cấu trúc của ngôn ngữ chủ yếu dựa trên C/C++ nên những người đã từng lập trình bằng ngôn ngữ này sẽ không gặp khó khăn gì khi thành thạo lập trình Arduino. Những người khác nên tìm hiểu thông tin cơ bản về các lệnh điều khiển, kiểu dữ liệu và chức năng.

Phần lớn thông tin ở đây sẽ tương thích với bất kỳ khóa học C/C++ nào, có tính đến sự khác biệt về kiểu dữ liệu cũng như một số hướng dẫn cụ thể về lập trình cổng I/O.

Khái niệm cơ bản

Một vài điều hình thức, tức là những điều ai cũng biết nhưng đôi khi lại quên mất...

Trong Arduino IDE, cũng như trong C/C++, bạn cần lưu ý đến các kiểu ký tự. Các từ khóa như if, for luôn được viết bằng chữ thường. Mỗi lệnh kết thúc bằng ";". Dấu chấm phẩy cho trình biên dịch biết phần nào sẽ được hiểu là một hướng dẫn.

Dấu ngoặc đơn (..) được sử dụng để biểu thị các khối chương trình. Chúng tôi sử dụng chúng để hạn chế các phần thân hàm (xem bên dưới), vòng lặp và câu lệnh điều kiện.

Đó là một cách tốt để thêm nhận xét vào nội dung của chương trình, điều này làm cho mã dễ hiểu. Nhận xét một dòng bắt đầu bằng // (dấu gạch chéo kép). Nhận xét nhiều dòng bắt đầu bằng /* và kết thúc bằng */

Nếu chúng tôi muốn đưa bất kỳ thư viện nào vào chương trình của mình, chúng tôi sử dụng lệnh include. Dưới đây là ví dụ về việc kết nối các thư viện:

#bao gồm // thư viện chuẩn #include "svoya_biblioteka.h" // thư viện trong thư mục dự án

Các hàm trong Arduino

Hàm (chương trình con) là một phần riêng biệt của chương trình thực hiện các hoạt động nhất định. Các hàm được sử dụng để đơn giản hóa chương trình chính và cải thiện khả năng đọc mã. Việc sử dụng các hàm rất hữu ích vì chúng ta có thể dễ dàng sử dụng chúng trong nhiều dự án của mình.

Khóa học lập trình tiêu chuẩn chứa thông tin về các hàm sẽ được trình bày trong các bài viết sau. Trong trường hợp của Arduino, các hàm sẽ được thảo luận ngay từ đầu vì ngay cả chương trình đơn giản nhất cũng phải có hai hàm đặc biệt. Điều này đã được đề cập trong các bài viết trước, nhưng ở đây chúng tôi hệ thống hóa thông tin này.

Khai báo hàm

Sơ đồ khai báo hàm trông như thế này:

Nhập function_name(parameter) ( // hướng dẫn thực thi (thân hàm) return (/* return value*/); )

kiểu là tên của bất kỳ loại dữ liệu có sẵn nào trong một ngôn ngữ lập trình nhất định. Chúng tôi sẽ cung cấp danh sách các loại có sẵn khi lập trình Arduino trong một bài viết riêng.

Sau khi thực thi, hàm sẽ trả về giá trị của kiểu đã khai báo. Nếu hàm không chấp nhận bất kỳ giá trị trả về nào thì kiểu dữ liệu sẽ là “void”.

Tên chức năng cho phép nó được nhận dạng duy nhất. Để gọi (chạy) một hàm, chúng ta đặt tên cho nó.

tham số- tham số gọi hàm. Các tham số không bắt buộc nhưng chúng thường hữu ích. Nếu chúng ta viết một hàm không có đối số, chúng ta để trống dấu ngoặc đơn.

Bên trong dấu ngoặc “(…)” là nội dung thực tế của hàm hoặc lệnh mà chúng ta muốn thực thi. Chúng tôi sẽ cung cấp mô tả về các hướng dẫn cụ thể trong một bài viết riêng.

Tất cả các hàm trả về một giá trị đều kết thúc bằng câu lệnh return, theo sau là giá trị trả về. Chỉ các hàm được khai báo bằng con trỏ null ("void") mới không chứa câu lệnh return. Bạn cần biết rằng câu lệnh return kết thúc hàm bất kể vị trí.

Dưới đây là một số ví dụ về khai báo hàm.

Void f1() ( // thân hàm) ——————————————— int trừ() ( // thân hàm return (0); ) ——————————— ——— int plus(int a, int b) ( return (a+b); )

Như bạn có thể thấy từ các ví dụ, việc khai báo hàm có thể có nhiều dạng tùy theo nhu cầu của bạn.

Chúng tôi thực sự khuyến khích bạn tìm hiểu và sử dụng các chức năng khi viết chương trình của riêng bạn. Theo thời gian, mỗi lập trình viên sẽ tích lũy thư viện hàm riêng của mình “cho mọi trường hợp”, điều này giúp việc viết chương trình mới trở nên dễ dàng và nhanh chóng hơn.

Bây giờ chúng ta đã biết cách viết hàm của riêng mình, chúng ta cần học cách sử dụng nó.

Gọi một hàm

Chúng tôi viết tất cả các chức năng trong một tập tin/chương trình. Tất nhiên, có một giải pháp tao nhã hơn, nhưng chúng tôi sẽ cố gắng mô tả nó vào lần tới.

Sau khi khai báo một hàm, chúng ta có thể sử dụng hàm đó trong các hàm khác với tên thích hợp và mọi tham số bắt buộc. Dưới đây là ví dụ về cách gọi các hàm chúng tôi đã đưa ra ở trên:

F1(); cộng(2,2); y=cộng(1.5);

Như bạn có thể thấy trong các ví dụ, lệnh gọi hàm được thực hiện bằng cách chỉ định tên của nó và số lượng tham số cần thiết. Điều quan trọng là luôn gọi một hàm như đã khai báo.

Nếu hàm f1() được khai báo mà không có tham số thì không thể chỉ định tham số nào khi gọi nó, tức là. gọi f1(0) sẽ không chính xác.

Hàm plus(int a, int b) yêu cầu chính xác hai tham số, do đó không thể gọi với một hoặc ba tham số.

Việc gọi y=plus(1,5) sẽ thực thi hàm "plus" với tham số "1" và "5" và lưu giá trị trả về vào biến "y".

các hàm setup() và loop().

Với kiến ​​thức về khai báo và gọi hàm, chúng ta có thể chuyển sang các hàm của hệ thống Arduino: cài đặt() Và vòng(). Arduino IDE được yêu cầu để khai báo hai hàm này.

setup() là một chức năng được gọi tự động khi bật nguồn hoặc nhấn nút RESET.

Đúng như tên gọi của nó, nó được sử dụng để đặt giá trị ban đầu của các biến, khai báo đầu vào và đầu ra của hệ thống, thường được chỉ định trong các tham số ban đầu. Do tính đặc hiệu của nó, hàm này không trả về giá trị và không được gọi kèm theo tham số. Khai báo hàm setup() đúng như dưới đây:

Thiết lập void () ( // thân hàm - khởi tạo hệ thống )

loop() là hàm được gọi trong vòng lặp vô hạn. Hàm này cũng không trả về giá trị và không được gọi kèm theo tham số. Khai báo hàm loop() đúng được hiển thị bên dưới:

Vòng lặp void () ( // thân hàm - mã chương trình )

Như bạn có thể thấy, khai báo hàm loop() giống hệt với khai báo hàm setup(). Sự khác biệt nằm ở việc thực hiện các chức năng này của bộ vi điều khiển.

Bây giờ chúng ta sẽ phân tích mã giả sau:

Void setup () ( on_led1 (); //bật led1 off_led1 (); //tắt led1) void loop () ( on_led2 (); //bật led2 off_led2 (); //tắt led2)

Có hai hướng dẫn trong hàm setup(): hướng dẫn đầu tiên bật led1 được kết nối với bo mạch (ví dụ: chân 13) và hướng dẫn thứ hai tắt led1.

Hàm loop() có hướng dẫn giống nhau để bật và tắt đèn LED2 được kết nối với bo mạch (ví dụ: chân 12).

Khi chạy chương trình, led1 sẽ nhấp nháy một lần, trong khi led2 sẽ sáng và tắt miễn là Arduino được bật nguồn.

Nhấn nút RESET sẽ khiến led1 nhấp nháy một lần nữa và led2 lại nhấp nháy liên tục.

Tóm tắt:

  • Các hàm setup() và loop() là các hàm hệ thống phải được xác định trong mọi dự án. Ngay cả trong trường hợp chúng ta không viết bất kỳ mã nào vào một trong số chúng, chúng ta vẫn phải khai báo hai hàm này;
  • Hàm setup() được thực thi một lần, loop() được thực thi liên tục;
  • Chúng tôi tạo các chức năng của riêng mình trong một tệp;
  • Chúng ta có thể gọi các hàm của mình từ cả setup() và loop() và từ các hàm khác;
  • Các hàm riêng của chúng ta có thể được gọi với các tham số và trả về một giá trị;
  • Một cuộc gọi hàm phải được thực hiện theo khai báo của nó.

Bạn sẽ cần

  • - Bo mạch Arduino UNO,
  • - Cáp USB (USB A - USB B),
  • - Máy tính cá nhân,
  • - Đi-ốt phát quang,
  • - điện trở 220 Ohm,
  • - một cặp dây 5-10 cm,
  • - nếu có - bảng mạch.

Hướng dẫn

Tải xuống môi trường phát triển Arduino cho hệ điều hành của bạn (hỗ trợ Windows, Mac OS X, Linux) trên trang http://arduino.cc/en/Main/Software, bạn có thể cài đặt trình cài đặt, bạn có thể. Tệp đã tải xuống cũng chứa trình điều khiển cho bo mạch Arduino.

Cài đặt trình điều khiển. Hãy xem xét tùy chọn cho hệ điều hành Windows. Để thực hiện việc này, hãy đợi cho đến khi hệ điều hành nhắc bạn cài đặt trình điều khiển. Sự suy sụp. Nhấn Win + Pause, khởi chạy Trình quản lý thiết bị. Tìm phần "Cổng (COM & LPT)". Bạn sẽ thấy một cổng ở đó có tên là "Arduino UNO (COMxx)". Nhấp chuột phải vào nó và chọn "Cập nhật trình điều khiển". Tiếp theo, chọn vị trí của trình điều khiển bạn vừa tải xuống.

Môi trường phát triển đã có sẵn nhiều ví dụ để nghiên cứu hoạt động của bo mạch. Mở ví dụ "Blink": Tệp > Ví dụ > 01.Basics > Blink.

Trỏ môi trường phát triển của bạn vào bảng của bạn. Để thực hiện việc này, trong menu Công cụ > Bảng, chọn "Arduino UNO".

Chọn cổng mà bo mạch Arduino được gán. Để biết bo mạch được kết nối với cổng nào, hãy khởi chạy Trình quản lý Thiết bị và tìm phần Cổng (COM & LPT). Cổng sẽ được chỉ định trong ngoặc đơn sau tên của bảng. Nếu bảng không có trong danh sách, hãy thử từ máy tính và đợi vài giây, thử lại.

Ngắt kết nối bo mạch khỏi máy tính. Lắp ráp mạch như hình vẽ. Các bạn lưu ý chân ngắn của LED phải nối vào chân GND, chân dài qua điện trở tới chân digital số 13 của board Arduino. Sẽ thuận tiện hơn khi sử dụng bảng mạch, nhưng nếu không có sẵn, bạn có thể kết nối dây bằng cách xoắn.
Lưu ý quan trọng! Chân kỹ thuật số 13 đã có điện trở riêng trên bảng. Do đó, khi kết nối đèn LED với bảng mạch, không nhất thiết phải sử dụng điện trở bên ngoài. Khi kết nối đèn LED với bất kỳ chân Arduino nào khác, việc sử dụng là bắt buộc!

Bây giờ bạn có thể tải chương trình vào bộ nhớ của bo mạch. Kết nối bo mạch với máy tính, đợi vài giây trong khi bo mạch khởi chạy. Nhấp vào nút "Tải lên" và nút của bạn sẽ được ghi vào bộ nhớ của bo mạch Arduino. Lập trình với Arduino rất trực quan và không khó chút nào. Nhìn vào hình ảnh - có những lời giải thích nhỏ trong phần bình luận cho chương trình. Điều này là đủ để bạn bắt đầu với thử nghiệm đầu tiên của mình.

Video về chủ đề

ghi chú

Hãy cẩn thận khi làm việc với bo mạch Arduino - đây là sản phẩm điện tử cần phải xử lý cẩn thận. Ở dưới cùng của bảng có các dây dẫn lộ ra ngoài và nếu bạn đặt bảng lên bề mặt dẫn điện thì có khả năng làm bảng bị cháy. Ngoài ra, không chạm vào bảng khi tay ẩm hoặc ướt và tránh những nơi ẩm ướt khi làm việc.

Lời khuyên hữu ích

Có rất nhiều trang web trên Internet dành riêng cho Arduino. Hãy đọc đi, chủ nhân, đừng ngại thử nghiệm và học hỏi những điều mới!

Nguồn:

  • Đèn LED nhấp nháy

Lập trình thu hút và quan tâm đến nhiều người hiện đại, đặc biệt là những người trẻ và những chuyên gia mới bắt đầu lựa chọn nghề nghiệp tương lai. Họ thường phải đối mặt với câu hỏi - học lập trình nên bắt đầu từ đâu? Nếu bạn quyết định học cách lập trình, bạn không nên mắc phải một lỗi phổ biến - đừng ngay lập tức tiếp nhận các hệ thống và ngôn ngữ phức tạp (ví dụ: C). Bắt đầu với một ngôn ngữ quá phức tạp có thể khiến bạn có ấn tượng sai lầm về lập trình nói chung. Người mới bắt đầu nên làm việc với các hệ thống đơn giản nhất - ví dụ: học cách viết chương trình bằng BASIC. Học ngôn ngữ này sẽ cho phép bạn đạt được kết quả tốt trong một thời gian ngắn. PureBasic rất dễ học - ngôn ngữ linh hoạt, được biên dịch mạnh mẽ này sẽ giúp bạn hiểu những kiến ​​thức cơ bản về lập trình và cải thiện kỹ năng của bạn trong tương lai.

Hướng dẫn

Bạn có thể mất khoảng một năm để học những điều cơ bản về lập trình. Bạn sẽ tìm hiểu các tính năng của lập trình hướng đối tượng và thủ tục, các nguyên tắc làm việc với cây nhị phân, mảng, danh sách, v.v. Chỉ sau khi học những điều cơ bản mới chuyển sang những nhiệm vụ phức tạp hơn.

Truy cập trang web của các nhà phát triển ngôn ngữ lập trình và tài liệu nghiên cứu. Hãy nhớ giao tiếp trên các diễn đàn dành cho lập trình viên; họ thường trả lời hầu hết các câu hỏi của người mới bắt đầu.

toán học

Nếu bạn muốn học lập trình, bạn chỉ cần biết toán. Trong quá trình làm việc, bạn sẽ gặp phải một số lượng lớn các vấn đề không thể giải quyết được nếu không có kiến ​​thức cơ bản về ngành khoa học này. Có một số lượng lớn các hệ thống và lý thuyết toán học (chuỗi Fourier, số Fibonacci, v.v.) giúp đơn giản hóa đáng kể quá trình lập trình.

Việc học không bao giờ kết thúc

Sự phát triển của các ngôn ngữ lập trình không đứng yên; sự phát triển của chúng vẫn đang diễn ra. Cố gắng đọc càng nhiều tài liệu càng tốt liên quan đến lĩnh vực lập trình mà bạn dự định làm việc. Hãy luôn tìm kiếm những cách khác để giải quyết vấn đề phát sinh, điều này sẽ giúp bạn không ngừng nâng cao hiệu quả của đoạn code mà bạn tạo ra. Nói chuyện với các lập trình viên chuyên nghiệp, họ sẽ luôn có thể tư vấn cách giải quyết một vấn đề cụ thể. Đọc mã của họ cũng sẽ mang lại lợi ích cho bạn rất nhiều.
Không thể nào lúc nào cũng giữ được mọi thứ trong đầu. Hãy thoải mái sử dụng sách tham khảo ngôn ngữ lập trình.

Các vấn đề về lập trình, dù đơn giản đến đâu, cũng không bao giờ được giải quyết ngay lập tức. Chúng luôn yêu cầu phát triển thuật toán hành động chính xác, hiệu quả trong một tình huống cụ thể nhất định. Việc tìm kiếm các thuật toán tối ưu đòi hỏi phải thực hành và đào tạo liên tục. Cố gắng giải quyết các vấn đề lập trình nhỏ thường xuyên hơn (bạn có thể tìm thấy chúng trên các trang web chuyên ngành), điều này sẽ giúp bạn dần dần trau dồi kỹ năng của mình trong lĩnh vực này.

Xin chào! Tôi là Alikin Alexander Sergeevich, giáo viên dạy bổ túc, tôi lãnh đạo câu lạc bộ “Robotics” và “Kỹ thuật vô tuyến” tại Trung tâm Công nghệ Thanh niên và Thanh niên ở Labinsk. Tôi muốn nói một chút về phương pháp lập trình Arduino đơn giản bằng chương trình ArduBlock.

Tôi đã đưa chương trình này vào quá trình giáo dục và rất vui với kết quả đạt được; nó được trẻ em yêu cầu rất nhiều, đặc biệt là khi viết các chương trình đơn giản hoặc để tạo một số giai đoạn đầu của các chương trình phức tạp. ArduBlock là một môi trường lập trình đồ họa, tức là tất cả các hành động được thực hiện bằng hình vẽ với các hành động được ký bằng tiếng Nga, giúp đơn giản hóa đáng kể việc học nền tảng Arduino. Trẻ em từ lớp 2 có thể dễ dàng làm chủ được Arduino nhờ chương trình này.

Vâng, ai đó có thể nói rằng Scratch vẫn tồn tại và nó cũng là một môi trường đồ họa rất đơn giản để lập trình Arduino. Nhưng Scratch không flash Arduino mà chỉ điều khiển nó qua cáp USB. Arduino phụ thuộc vào máy tính và không thể hoạt động tự động. Khi tạo các dự án của riêng bạn, quyền tự chủ là điều quan trọng nhất đối với Arduino, đặc biệt là khi tạo ra các thiết bị robot.

Ngay cả những robot LEGO nổi tiếng, chẳng hạn như NXT hay EV3, cũng không còn quá thú vị đối với học sinh của chúng ta với sự ra đời của chương trình ArduBlock trong lập trình Arduino. Arduino cũng rẻ hơn nhiều so với bất kỳ bộ dụng cụ xây dựng LEGO nào và nhiều bộ phận có thể được lấy đơn giản từ các thiết bị điện tử gia dụng cũ. Chương trình ArduBlock sẽ giúp ích không chỉ cho người mới bắt đầu mà còn cả những người dùng tích cực của nền tảng Arduino.

Vậy ArduBlock là gì? Như tôi đã nói, đây là môi trường lập trình đồ họa. Gần như được dịch hoàn toàn sang tiếng Nga. Nhưng điểm nổi bật của ArduBlock không chỉ ở điều này mà còn ở việc chương trình ArduBlock chúng tôi viết chuyển đổi thành mã Arduino IDE. Chương trình này được tích hợp vào môi trường lập trình Arduino IDE, tức là nó là một plugin.

Dưới đây là ví dụ về đèn LED nhấp nháy và chương trình được chuyển đổi trong Arduino IDE. Mọi công việc với chương trình đều rất đơn giản và bất kỳ học sinh nào cũng có thể hiểu được.

Nhờ làm việc với chương trình, bạn không chỉ có thể lập trình Arduino mà còn có thể nghiên cứu các lệnh mà chúng ta không hiểu ở định dạng văn bản của Arduino IDE, nhưng nếu quá lười viết lệnh tiêu chuẩn, bạn có thể nhanh chóng sử dụng chuột để phác thảo một chương trình đơn giản trong ArduBlok và gỡ lỗi nó trong Arduino IDE.

Để cài đặt ArduBlok, trước tiên bạn phải tải xuống và cài đặt Arduino IDE từ trang web Arduino chính thức và hiểu các cài đặt khi làm việc với bo mạch Arduino UNO. Cách thực hiện việc này được mô tả trên cùng một trang web hoặc trên Amperka hoặc xem trên YouTube. Chà, khi tất cả những điều này đã được giải quyết, bạn cần tải xuống ArduBlok từ trang web chính thức tại đây. Tôi không khuyên bạn nên tải xuống các phiên bản mới nhất, chúng rất phức tạp đối với người mới bắt đầu, nhưng phiên bản từ 2013-07-12 là tốt nhất, tệp này phổ biến nhất ở đó.

Sau đó, đổi tên tệp đã tải xuống thành ardublock-all và trong thư mục “tài liệu”. Chúng tôi tạo các thư mục sau: Arduino > tools > ArduBlockTool > tool và trong thư mục sau, chúng tôi sẽ ném tệp đã tải xuống và đổi tên. ArduBlok hoạt động trên tất cả các hệ điều hành, kể cả trên Linux, cá nhân tôi đã thử nghiệm nó trên XP, Win7, Win8, tất cả các ví dụ đều dành cho Win7. Việc cài đặt chương trình là giống nhau cho tất cả các hệ thống.

Chà, nói một cách đơn giản, tôi đã chuẩn bị một kho lưu trữ trên đĩa Mail 7z, giải nén bạn sẽ tìm thấy 2 thư mục. Trong một thư mục đã có chương trình Arduino IDE đang hoạt động và trong thư mục kia, nội dung phải được gửi đến thư mục tài liệu.

Để hoạt động trong ArduBlok, bạn cần chạy Arduino IDE. Sau đó, chúng ta chuyển đến tab Công cụ và ở đó chúng ta tìm thấy mục ArduBlok, nhấp vào nó - và đây là mục tiêu của chúng ta.

Bây giờ chúng ta hãy nhìn vào giao diện chương trình. Như bạn đã hiểu, không có cài đặt nào trong đó, nhưng có rất nhiều biểu tượng để lập trình và mỗi biểu tượng mang một lệnh ở định dạng văn bản Arduino IDE. Các phiên bản mới thậm chí còn có nhiều biểu tượng hơn nên rất khó hiểu phiên bản mới nhất của ArduBlok và một số biểu tượng không được dịch sang tiếng Nga.

Trong phần "Quản lý", chúng ta sẽ tìm thấy nhiều chu kỳ khác nhau.

Trong phần “Cổng”, chúng ta có thể quản lý các giá trị của các cổng, cũng như bộ phát âm thanh, cảm biến tiệm cận servo hoặc siêu âm được kết nối với chúng.

Trong phần “Số/Hằng số”, chúng ta có thể chọn các giá trị số hoặc tạo một biến, nhưng bạn khó có thể sử dụng những gì bên dưới.

Trong phần “Toán tử”, chúng ta sẽ tìm thấy tất cả các toán tử so sánh và tính toán cần thiết.

Phần Tiện ích chủ yếu sử dụng biểu tượng hẹn giờ.

"TinkerKit Bloks" là phần dành cho các cảm biến TinkerKit đã mua. Tất nhiên, chúng tôi không có bộ như vậy, nhưng điều này không có nghĩa là các biểu tượng không phù hợp với các bộ khác, ngược lại, rất thuận tiện cho các chàng sử dụng các biểu tượng như bật đèn LED hoặc đèn LED. cái nút. Những dấu hiệu này được sử dụng trong hầu hết các chương trình. Nhưng chúng có một điểm đặc biệt - khi bạn chọn chúng, có các biểu tượng biểu thị cổng không chính xác, vì vậy bạn cần xóa chúng và thay thế biểu tượng từ phần “số/hằng số” ở đầu danh sách.

“DF Robot” - phần này được sử dụng nếu có các cảm biến được chỉ định trong đó, đôi khi chúng được tìm thấy. Và ví dụ của chúng tôi hôm nay cũng không ngoại lệ, chúng tôi có “Công tắc hồng ngoại có thể điều chỉnh” và “Cảm biến đường truyền”. “Cảm biến đường truyền” khác với cảm biến trong hình vì nó là của công ty Amperka. Hoạt động của chúng giống hệt nhau, nhưng cảm biến Ampere tốt hơn nhiều vì nó có bộ điều chỉnh độ nhạy.

“Seedstudio Grove” - Tôi chưa bao giờ sử dụng các cảm biến trong phần này, mặc dù chỉ có cần điều khiển. Trong các phiên bản mới, phần này đã được mở rộng.

Và phần cuối cùng là “Linker Kit”. Tôi không nhìn thấy các cảm biến được trình bày trong đó.

Tôi muốn đưa ra một ví dụ về chương trình trên một robot di chuyển dọc theo một dải. Robot rất đơn giản, cả để lắp ráp và mua hàng, nhưng điều đầu tiên phải làm trước tiên. Hãy bắt đầu với việc mua lại và lắp ráp nó.

Đây là bộ linh kiện, mọi thứ đều được mua trên trang web Amperka.

  1. Tấm chắn động cơ AMP-B001 (2 kênh, 2 A) 1.890 RUB
  2. Khiên Troyka AMP-B017 RUB 1.690
  3. AMP-X053 Ngăn chứa pin 3×2 AA 1 60 RUR
  4. Cảm biến đường truyền kỹ thuật số AMP-B018 RUB 2.580
  5. ROB0049 Xe hai bánh MiniQ 1.1890 RUB
  6. SEN0019 Cảm biến chướng ngại vật hồng ngoại RUB 1.390
  7. FIT0032 Giá đỡ cho cảm biến chướng ngại vật hồng ngoại RUB 1,90
  8. A000066 Arduino Uno 1 1150 RUR

Đầu tiên, hãy lắp ráp bệ có bánh xe và hàn dây vào động cơ.

Sau đó, chúng ta sẽ lắp đặt các giá đỡ để gắn bo mạch Arduino UNO được lấy từ bo mạch chủ cũ hoặc các giá đỡ tương tự khác.

Sau đó, chúng tôi gắn bo mạch Arduino UNO vào các giá đỡ này, nhưng chúng tôi sẽ không thể siết chặt một bu lông - các đầu nối đang bị vướng. Tất nhiên, bạn có thể hàn lại chúng, nhưng điều này tùy theo quyết định của bạn.

Tiếp theo, chúng tôi gắn cảm biến chướng ngại vật hồng ngoại vào giá đỡ đặc biệt của nó. Xin lưu ý rằng bộ điều chỉnh độ nhạy được đặt ở phía trên, để dễ điều chỉnh.

Bây giờ chúng tôi cài đặt các cảm biến đường dây kỹ thuật số, ở đây bạn sẽ phải tìm một vài bu lông và 4 đai ốc cho chúng. Chúng tôi lắp hai đai ốc giữa chính bệ và cảm biến đường dây, đồng thời cố định các cảm biến với phần còn lại.

Tiếp theo chúng ta cài đặt Motor Shield, hay nói cách khác bạn có thể gọi nó là trình điều khiển động cơ. Trong trường hợp của chúng tôi, hãy chú ý đến jumper. Chúng tôi sẽ không sử dụng nguồn điện riêng cho động cơ nên nó được lắp đặt ở vị trí này. Phần dưới được bịt kín bằng băng keo điện để đề phòng trường hợp ngắn mạch ngẫu nhiên từ đầu nối USB Arduino UNO.

Chúng tôi lắp Troyka Shield lên trên Tấm chắn động cơ. Nó là cần thiết để thuận tiện cho việc kết nối các cảm biến. Tất cả các cảm biến chúng tôi sử dụng đều là kỹ thuật số, vì vậy cảm biến đường truyền được kết nối với cổng 8 và 9, vì chúng còn được gọi là chân và cảm biến chướng ngại vật hồng ngoại được kết nối với cổng 12. Hãy nhớ lưu ý rằng các cổng 4, 5, 6, 7 không thể được sử dụng vì chúng được Motor Shield sử dụng để điều khiển động cơ. Tôi thậm chí còn đặc biệt sơn lên các cổng này bằng bút đánh dấu màu đỏ để học sinh có thể hình dung.

Nếu bạn đã nhận thấy, tôi đã thêm một ống lót màu đen để đề phòng để ngăn chứa pin mà chúng tôi lắp đặt không bay ra ngoài. Và cuối cùng, chúng tôi cố định toàn bộ cấu trúc bằng dây thun thông thường.

Có 2 loại kết nối ngăn chứa pin. Kết nối dây đầu tiên với Troyka Shield. Cũng có thể hàn phích cắm nguồn và kết nối nó với bo mạch Arduino UNO.

Robot của chúng tôi đã sẵn sàng. Trước khi bắt đầu lập trình, bạn sẽ cần tìm hiểu cách mọi thứ hoạt động, cụ thể là:
- Động cơ:
Cổng 4 và 5 được sử dụng để điều khiển một động cơ, và 6 và 7 cổng khác;
Chúng tôi điều chỉnh tốc độ quay của động cơ bằng cách sử dụng PLC trên cổng 5 và 6;
Tiến hoặc lùi bằng cách gửi tín hiệu đến cổng 4 và 7.
- Cảm biến:
Tất cả chúng ta đều là kỹ thuật số, vì vậy chúng đưa ra các tín hiệu logic ở dạng 1 hoặc 0;
Và để điều chỉnh chúng, chúng có các bộ điều chỉnh đặc biệt và với sự trợ giúp của một tuốc nơ vít phù hợp, chúng có thể được hiệu chỉnh.

Thông tin chi tiết có thể được tìm thấy tại Amperke. Tại sao ở đây? Bởi vì có rất nhiều thông tin về cách làm việc với Arduino.

Chà, có lẽ chúng ta đã xem xét mọi thứ một cách hời hợt, nghiên cứu nó và tất nhiên là lắp ráp robot. Bây giờ nó cần được lập trình, đây rồi - chương trình đã được chờ đợi từ lâu!

Và chương trình đã chuyển đổi sang Arduino IDE:

Void setup() ( pinMode(8 , INPUT); pinMode(12 , INPUT); pinMode(9 , INPUT); pinMode(4 , OUTPUT); pinMode(7 , OUTPUT); pinMode(5, OUTPUT); pinMode(6 , OUTPUT); ) void loop() ( if (digitalRead(12)) ( if (digitalRead(8)) ( if (digitalRead(9)) ( digitalWrite(4, HIGH); analogWrite(5, 255); analogWrite( 6, 255); digitalWrite(7, HIGH); ) else ( digitalWrite(4, HIGH); analogWrite(5, 255); analogWrite(6, 50); digitalWrite(7, LOW); ) ) else ( if (digitalRead (9)) ( digitalWrite(4, LOW); analogWrite(5, 50); analogWrite(6, 255); digitalWrite(7, HIGH); ) else ( digitalWrite(4, HIGH); analogWrite(5, 255); analogWrite(6, 255); digitalWrite(7, HIGH); ) khác ( digitalWrite(4, HIGH); analogWrite(5, 0); analogWrite(6, 0); digitalWrite(7, HIGH); ) )

Tóm lại, tôi muốn nói rằng chương trình này đơn giản là một món quà trời cho dành cho giáo dục; ngay cả khi tự học, nó sẽ giúp bạn học các lệnh Arduino IDE. Điểm nổi bật chính là có hơn 50 icon cài đặt, bắt đầu “trục trặc”. Vâng, thực sự, đây là điểm nổi bật, vì việc lập trình chỉ trên ArduBlok mọi lúc sẽ không dạy bạn lập trình trong Arduino IDE. Cái gọi là "trục trặc" cho bạn cơ hội suy nghĩ và cố gắng ghi nhớ các lệnh để gỡ lỗi chương trình một cách chính xác.

Chúc các bạn thành công.