Arduino Programing – 07– Data Types

Data Types

Dưới đây là mô tả chi tiết các kiểu dữ liệu mà bạn đã liệt kê, bao gồm cả ví dụ và giải thích về cách sử dụng chúng trong Arduino:

1. array (Mảng)

• Mô tả:
  • Mảng là một cấu trúc dữ liệu có thể lưu trữ nhiều giá trị cùng loại.
  • Các phần tử trong mảng có thể được truy cập thông qua chỉ mục (index).

• Ví dụ:

  int numbers[5] = {1, 2, 3, 4, 5};
  
  void setup() {
  Serial.begin(9600);
  for (int i = 0; i < 5; i++) {
    Serial.println(numbers[i]);
  }
  }

2. bool

• Mô tả:
  • Lưu trữ giá trị logic true hoặc false.
  • Là kiểu dữ liệu có kích thước 1 byte trên một số vi điều khiển.

• Ví dụ:

  bool isOn = true;
  
  void loop() {
  if (isOn) {
    Serial.println("Đang bật!");
  } else {
    Serial.println("Đang tắt!");
  }
  delay(1000);
  }

3. boolean

• Mô tả:
  • Tương tự như bool, lưu trữ giá trị true hoặc false.
  • boolean là một từ khóa kiểu dữ liệu đặc biệt trong Arduino (không có sự khác biệt lớn giữa bool và boolean trong Arduino).

• Ví dụ:

  boolean lightOn = false;
  
  void loop() {
  if (lightOn) {
    digitalWrite(LED_BUILTIN, HIGH);
  } else {
    digitalWrite(LED_BUILTIN, LOW);
  }
  delay(1000);
  }

4. byte

• Mô tả:
  • Lưu trữ số nguyên không dấu từ 0 đến 255.
  • Chiếm 1 byte bộ nhớ.

• Ví dụ:

  byte counter = 0;
  
  void loop() {
  Serial.println(counter);
  counter++;
  delay(1000);
  }

5. char

• Mô tả:
  • Lưu trữ một ký tự ASCII hoặc một số nguyên có dấu trong phạm vi -128 đến 127.
  • Chiếm 1 byte bộ nhớ.

• Ví dụ:

  char c = 'A';
  
  void loop() {
  Serial.println(c);
  delay(1000);
  }

6. double

• Mô tả:
  • Lưu trữ số thực, có dấu với độ chính xác cao hơn float. Tuy nhiên, trên một số vi điều khiển, double và float có cùng độ chính xác.
  • Chiếm 4 byte bộ nhớ.

• Ví dụ:

  double pi = 3.14159265359;
  
  void loop() {
  Serial.println(pi, 10);
  delay(1000);
  }

7. float

• Mô tả:
  • Lưu trữ số thực, có dấu.
  • Chiếm 4 byte bộ nhớ.

• Ví dụ:

  float temp = 25.5;
  
  void loop() {
  Serial.println(temp);
  delay(1000);
  }

8. int

• Mô tả:
  • Lưu trữ số nguyên có dấu từ -32,768 đến 32,767 (16-bit).
  • Chiếm 2 byte bộ nhớ.

• Ví dụ:

  int counter = 100;
  
  void loop() {
  Serial.println(counter);
  counter++;
  delay(1000);
  }

9. long

• Mô tả:
  • Lưu trữ số nguyên có dấu từ -2,147,483,648 đến 2,147,483,647 (32-bit).
  • Chiếm 4 byte bộ nhớ.

• Ví dụ:

  long largeNumber = 1000000000;
  
  void loop() {
  Serial.println(largeNumber);
  delay(1000);
  }

10. short

• Mô tả:
  • Lưu trữ số nguyên có dấu từ -32,768 đến 32,767 (16-bit).
  • Chiếm 2 byte bộ nhớ.

• Ví dụ:

  short smallNumber = 200;
  
  void loop() {
  Serial.println(smallNumber);
  delay(1000);
  }

11. size_t

• Mô tả:
  • Là kiểu dữ liệu không dấu, được sử dụng để chỉ số lượng hoặc kích thước, thường được sử dụng trong các chỉ số mảng hoặc số lượng phần tử.
  • Kích thước của size_t phụ thuộc vào kiến trúc của vi điều khiển (thường là 2 byte trên vi điều khiển 8-bit và 4 byte trên vi điều khiển 32-bit).

• Ví dụ:

  size_t arraySize = 10;
  int arr[arraySize] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  
  void loop() {
  for (size_t i = 0; i < arraySize; i++) {
    Serial.println(arr[i]);
  }
  delay(1000);
  }

12. string

• Mô tả:
  • Là kiểu chuỗi ký tự đơn giản (không phải là đối tượng String() trong Arduino).
  • Thường được sử dụng trong C++ chuẩn, nhưng có thể sử dụng trong Arduino thông qua thư viện String.h.

• Ví dụ:

  string message = "Hello, World!";
  
  void loop() {
  Serial.println(message.c_str());  // Chuyển đổi string thành char[] để in ra
  delay(1000);
  }

13. String()

• Mô tả:
  • Là một lớp đối tượng trong Arduino để làm việc với chuỗi ký tự.
  • Khác với kiểu char[], String cho phép sử dụng các phương thức thao tác với chuỗi ký tự một cách dễ dàng.

• Ví dụ:

  String message = "Hello";
  
  void loop() {
  message += " Arduino!";  // Nối chuỗi
  Serial.println(message);
  delay(1000);
  }

  14. unsigned char

• Mô tả:
  • Lưu trữ số nguyên không dấu từ 0 đến 255.
  • Chiếm 1 byte bộ nhớ.

• Ví dụ:

  unsigned char value = 200;
  
  void loop() {
  Serial.println(value);
  delay(1000);
  }

15. unsigned int

• Mô tả:
  • Lưu trữ số nguyên không dấu từ 0 đến 65,535.
  • Chiếm 2 byte bộ nhớ.

• Ví dụ:

  unsigned int count = 60000;
  
  void loop() {
  Serial.println(count);
  delay(1000);
  }

16. unsigned long

• Mô tả:
  • Lưu trữ số nguyên không dấu từ 0 đến 4,294,967,295.
  • Chiếm 4 byte bộ nhớ.

• Ví dụ:

  unsigned long timestamp = millis();
  
  void loop() {
  Serial.println(timestamp);
  delay(1000);
  }

17. void

• Mô tả:
  • Dùng để chỉ các hàm không trả về giá trị.

• Ví dụ:

  void setup() {
  Serial.begin(9600);
  }
  
  void loop() {
  Serial.println("Đây là hàm không trả về giá trị");
  delay(1000);
  }

18. word

• Mô tả:
  • Là kiểu dữ liệu số nguyên không dấu tương tự như unsigned int, nhưng giá trị của nó nằm trong phạm vi 0 đến 65,535.
  • Chiếm 2 byte bộ nhớ.

• Ví dụ:

  word temperature = 1000;
  
  void loop() {
  Serial.println(temperature);
  delay(1000);
  }

Dưới đây là bảng tóm tắt các kiểu dữ liệu trong Arduino mà bạn yêu cầu:

Kiểu Dữ Liệu	Mô Tả	Phạm Vi Giá Trị	Kích Thước Bộ Nhớ
array	Cấu trúc dữ liệu chứa nhiều giá trị cùng loại.	Tùy thuộc vào số phần tử.	Tùy thuộc vào kích thước mảng
bool	Lưu trữ giá trị logic true hoặc false.	true hoặc false	1 byte
boolean	Tương tự bool, lưu trữ giá trị logic true hoặc false.	true hoặc false	1 byte
byte	Số nguyên không dấu từ 0 đến 255.	0 đến 255	1 byte
char	Lưu trữ ký tự ASCII hoặc số nguyên có dấu.	-128 đến 127	1 byte
double	Số thực với độ chính xác cao hơn float.	Tùy thuộc vào vi điều khiển (thường giống float)	4 byte
float	Số thực có dấu, độ chính xác thấp hơn double.	Tùy thuộc vào vi điều khiển	4 byte
int	Số nguyên có dấu từ -32,768 đến 32,767.	-32,768 đến 32,767	2 byte
long	Số nguyên có dấu từ -2,147,483,648 đến 2,147,483,647.	-2,147,483,648 đến 2,147,483,647	4 byte
short	Số nguyên có dấu từ -32,768 đến 32,767.	-32,768 đến 32,767	2 byte
size_t	Dùng để chỉ số lượng hoặc kích thước.	Tùy thuộc vào kiến trúc vi điều khiển	2 byte (8-bit) hoặc 4 byte (32-bit)
string	Chuỗi ký tự trong C++ chuẩn (không phải String() Arduino).	Tùy thuộc vào chuỗi ký tự	Tùy thuộc vào chiều dài chuỗi
String()	Lớp đối tượng dùng cho chuỗi ký tự trong Arduino.	Tùy thuộc vào chuỗi ký tự	Tùy thuộc vào chuỗi ký tự
unsigned char	Số nguyên không dấu từ 0 đến 255.	0 đến 255	1 byte
unsigned int	Số nguyên không dấu từ 0 đến 65,535.	0 đến 65,535	2 byte
unsigned long	Số nguyên không dấu từ 0 đến 4,294,967,295.	0 đến 4,294,967,295	4 byte
void	Dùng cho các hàm không trả về giá trị.	Không có giá trị trả về	-
word	Số nguyên không dấu từ 0 đến 65,535 (tương tự unsigned int).	0 đến 65,535	2 byte