ตัวแปร Arduino ที่พบบ่อยที่สุดมีอะไรบ้าง? ใช้เขียนโปรแกรมอย่างไร
ตัวแปร Arduino คือหัวใจสำคัญของการเขียนโปรแกรมที่เหมือนกล่องเก็บข้อมูล สำหรับจัดเก็บค่าต่าง ๆ จากเซนเซอร์ หรือสถานะการทำงานของอุปกรณ์ หากต้องการสร้างโปรเจกต์ตั้งแต่การสั่งเปิด-ปิดไฟ ไปจนถึงการควบคุมหุ่นยนต์ การเข้าใจพื้นฐานของตัวแปรจะช่วยให้โค้ดของคุณทำงานได้อย่างแม่นยำและประหยัดพื้นที่หน่วยความจำในไมโครคอนโทรลเลอร์
บทความนี้ Global Byte จะพามาเจาะลึกทุกแง่มุมของตัวแปรที่คุณต้องรู้ เพื่อให้คุณสามารถเลือกใช้ชนิดข้อมูลที่เหมาะสมและเขียนโปรแกรมได้อย่างมืออาชีพ ตามไปดูรายละเอียดพร้อมกันเลย
Key Takeaways
- ตัวแปร Arduino คือที่เก็บข้อมูลในหน่วยความจำ โดยต้องเลือกชนิดให้เหมาะกับข้อมูล เช่น int สำหรับเลขจำนวนเต็ม หรือ float สำหรับทศนิยม
- ตัวแปร Arduino มีขนาดบิตที่ต่างกัน เช่น byte (8 บิต) เก็บค่าได้ 0-255 ซึ่งการเลือกใช้ชนิดที่เล็กที่สุดที่รองรับข้อมูลได้จะช่วยประหยัด SRAM
- ตัวแปร Global ประกาศนอกฟังก์ชันใช้ได้ทุกที่ ส่วน Local ประกาศในฟังก์ชันใช้ได้เฉพาะในพื้นที่นั้น ช่วยให้จัดการโครงสร้างโค้ดได้ดีขึ้น
- การเติม const หน้าตัวแปรสำหรับค่าที่ไม่เปลี่ยนแปลง เช่น ขา Pin จะช่วยป้องกันการเขียนทับค่าโดยไม่ตั้งใจและเพิ่มความเสถียรให้โปรแกรม
- ข้าใจการใช้ arrays สำหรับเก็บข้อมูลชุดใหญ่ และ unsigned สำหรับขยายขอบเขตค่าบวก เช่น การใช้ unsigned long กับฟังก์ชันเวลา
สารบัญบทความ
ตัวแปร Arduino มีกี่ชนิด
ตัวแปร Arduino มีคุณสมบัติอะไรบ้าง
ตัวอย่างการประกาศตัวแปร Arduino
สามารถใช้ตัวแปร Arduino ได้อย่างไร
คำถามที่พบได้บ่อย (FAQs)
เขียนโค้ดให้โปรด้วยตัวแปร Arduino พร้อมเลือกซื้ออุปกรณ์แท้ที่ Global Byte
ตัวแปร Arduino มีกี่ชนิด
ในการเขียนโปรแกรม Arduino (ซึ่งใช้ภาษา C++) ชนิดของตัวแปร Arduino (Data Types) จะถูกกำหนดตามขนาดของข้อมูลและความละเอียดที่ต้องการ การเลือกชนิดตัวแปร Arduino แต่ละรุ่นที่ถูกต้องมีความสำคัญมาก เนื่องจากบอร์ด Arduino มีหน่วยความจำ (SRAM) ที่จำกัด
1. boolean (บูลีน)
Arduino เก็บค่าตัวแปรทางตรรกศาสตร์ที่มีเพียง 2 สถานะเท่านั้น คือ TRUE (จริง) หรือ FALSE (เท็จ) ซึ่งในทางเทคนิคจะแทนด้วยค่า 1 และ 0 ตามลำดับ มักใช้ในการตรวจสอบเงื่อนไข (Condition) เช่น การเช็กสถานะปุ่มกด หรือการสร้าง Flag เพื่อควบคุมการทำงานของโปรแกรม Arduino ให้เป็นไปตามตรรกะที่วางไว้
|
ตัวอย่าง
boolean buttonState = false; // สร้างตัวแปรเก็บสถานะปุ่ม (ยังไม่กด)
boolean ledOn = true; // สร้างตัวแปรเก็บสถานะไฟ (เปิดอยู่)
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor ที่ความเร็ว 9600
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("buttonState = ");
Serial.println(buttonState);
Serial.print("ledOn = ");
Serial.println(ledOn);
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
buttonState = 0
ledOn = 1
|
2. char (ตัวอักษร)
เป็นตัวแปร Arduino ที่ใช้เก็บข้อมูลขนาด 8 บิต (1 ไบต์) ออกแบบมาเพื่อเก็บ "ตัวอักษรเดี่ยว" เพียงตัวเดียวตามมาตรฐานรหัส ASCII เราสามารถกำหนดค่าให้มันได้หลายวิธี ไม่ว่าจะเป็นการเขียนตัวอักษรไว้ในเครื่องหมายฝันหนูเดี่ยว (เช่น 'A') หรือจะระบุเป็นรหัสเลขฐานสิบ (เช่น 65) หรือเลขฐานสิบหก (เช่น 0x41) ก็ได้ ซึ่งทั้งหมดนี้ล้วนหมายถึงตัวอักษรเดียวกัน
|
ตัวอย่าง
char myGrade = 'A'; // เก็บตัวอักษร A
char myChar = 65; // ให้ผลลัพธ์เป็นตัวอักษร A เช่นกัน (รหัส ASCII)
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("myGrade = ");
Serial.println(myGrade); // แสดงผล: A
Serial.print("myChar = ");
Serial.println(myChar); // แสดงผล: A
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
myGrade = A
myChar = A
|
3. byte (ไบต์)
Arduino คือตัวแปรที่ใช้เก็บค่าข้อมูลตัวเลขจำนวนเต็มบวกขนาด 8 บิต ซึ่งจะมีลักษณะเหมือนกับ unsigned char ในภาษา C มาตรฐาน ตัวแปรชนิดนี้ไม่คิดเครื่องหมาย (ไม่มีค่าติดลบ) ทำให้สามารถเก็บค่าตัวเลขได้ตั้งแต่ 0 ถึง 255 เหมาะสำหรับประหยัดหน่วยความจำเมื่อเราทราบแน่นอนว่าค่าที่ใช้จะไม่เกินช่วงดังกล่าว เช่น การเก็บค่าความสว่างของ LED (PWM)
|
ตัวอย่าง
byte brightness = 150; // กำหนดค่าความสว่างในช่วง 0-255
byte sensorPin = 2; // กำหนดหมายเลขขา Digital
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("brightness = ");
Serial.println(brightness); // แสดงผล: 150
Serial.print("sensorPin = ");
Serial.println(sensorPin); // แสดงผล: 2
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
brightness = 150
sensorPin = 2
|
4. int หรือ Integer (จำนวนเต็ม)
เป็นตัวแปร Arduino พื้นฐานที่สุดสำหรับเก็บเลขจำนวนเต็มขนาด 16 บิต (บนบอร์ด Arduino ส่วนใหญ่เช่น Uno) โดยเป็นการเก็บแบบคิดเครื่องหมาย (Signed) ทำให้รองรับทั้งค่าบวกและค่าลบ ตัวแปรชนิดนี้สามารถเก็บค่าได้ทั้งหมด 65,536 ค่า โดยมีช่วงตั้งแต่ -32,768 ถึง +32,767 มักใช้เป็นตัวนับรอบใน loop หรือเก็บค่าจากเซนเซอร์ทั่วไป
|
ตัวอย่าง
int temperature = -10; // เก็บค่าอุณหภูมิที่อาจติดลบได้
int counter = 1000; // เก็บค่าตัวนับ
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("temperature = ");
Serial.println(temperature); // แสดงผล: -10
Serial.print("counter = ");
Serial.println(counter); // แสดงผล: 1000
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
temperature = -10
counter = 1000
|
5. unsigned int (จำนวนเต็มไม่คิดเครื่องหมาย)
ตัวแปร Arduino มีขนาด 16 บิต เท่ากับ int แต่จะแตกต่างกันตรงที่จะไม่เก็บค่าติดลบเลย (Unsigned) พื้นที่ทั้งหมดจึงถูกนำมาใช้เก็บเฉพาะเลขจำนวนเต็มบวก ทำให้สามารถขยับช่วงการเก็บข้อมูลไปได้สูงกว่าเดิมคือตั้งแต่ 0 ถึง 65,535 เหมาะสำหรับกรณีที่ต้องการค่าที่สูงกว่า 32,767 แต่ยังต้องการประหยัดแรมมากกว่าการใช้ long
|
ตัวอย่าง
unsigned int waterLevel = 45000; // เก็บค่าที่สูงกว่า int ปกติแต่ไม่ติดลบ
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("waterLevel = ");
Serial.println(waterLevel); // แสดงผล: 45000
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
waterLevel = 45000
|
6. long (จำนวนเต็มขนาดใหญ่)
ในกรณีที่ตัวเลขมีค่าสูงเกินกว่าที่ int จะรับไหว เราจะใช้ long ซึ่งมีขนาดใหญ่ถึง 32 บิต ตัวแปรชนิดนี้เก็บแบบคิดเครื่องหมาย ทำให้รองรับค่าได้กว้างมากตั้งแต่ -2,147,483,648 ถึง 2,147,483,647 มักใช้ในงานที่ต้องคำนวณตัวเลขจำนวนมหาศาลหรือการนับเวลาในหน่วยที่ละเอียดมาก
|
ตัวอย่าง
long speedOfLight = 299792458; // เก็บค่าตัวเลขที่มีขนาดใหญ่มาก
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("speedOfLight = ");
Serial.println(speedOfLight); // แสดงผล: 299792458
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
speedOfLight = 299792458
|
7. unsigned long (จำนวนเต็มขนาดใหญ่ไม่คิดเครื่องหมาย)
เป็นตัวแปร Arduino ขนาด 32 บิต ที่ไม่คิดเครื่องหมาย ทำให้สามารถเก็บค่าเป็นบวกได้เพียงอย่างเดียว แต่ให้ช่วงที่สูงขึ้นไปอีกคือตั้งแต่ 0 ถึง 4,294,967,295 ตัวแปรชนิดนี้มีความสำคัญมากใน Arduino โดยเฉพาะการใช้งานร่วมกับฟังก์ชัน millis() เพื่อดึงเวลาการทำงานของเครื่องที่เป็นหน่วยมิลลิวินาที ซึ่งมีค่าสะสมสูงขึ้นเรื่อย ๆ
|
ตัวอย่าง
unsigned long previousMillis = 0; // มักใช้คู่กับฟังก์ชัน millis() เพื่อจับเวลา
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("previousMillis = ");
Serial.println(previousMillis); // แสดงผล: 0
Serial.print("millis() = ");
Serial.println(millis()); // แสดงเวลาปัจจุบันนับตั้งแต่เปิดบอร์ด
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
previousMillis = 0
millis() = 1023
|
8. float (ทศนิยม)
เมื่อต้องการทำงานกับตัวเลขที่มีจุดทศนิยม เราจะเลือกใช้ float ซึ่งมีขนาด 32 บิต ตัวแปรชนิดนี้รองรับทั้งค่าบวกและลบ โดยมีความสามารถในการเก็บค่าได้กว้างมากตั้งแต่น้อยมากระดับ $3.4 \times 10^{-38}$ ไปจนถึงมหาศาลระดับ $3.4 \times 10^{+38}$ อย่างไรก็ตาม ความแม่นยำของทศนิยมจะจำกัดอยู่ที่ประมาณ 6-7 ตำแหน่งเท่านั้น
|
ตัวอย่าง
float pi = 3.14159; // เก็บค่าคงที่พาย
float voltage = 4.75; // เก็บค่าแรงดันไฟฟ้าจากเซนเซอร์
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("pi = ");
Serial.println(pi); // แสดงผล: 3.14
Serial.print("voltage = ");
Serial.println(voltage); // แสดงผล: 4.75
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
pi = 3.14
voltage = 4.75
|
9. double (ทศนิยมความละเอียดสูง)
ตัวแปร Arduino ประเภทนี้ใช้เก็บค่าทศนิยมเช่นเดียวกับ float แต่ถูกออกแบบมาให้มีความละเอียดสูงกว่า (Precision) โดยสามารถเก็บค่าได้มากถึง $1.7 \times 10^{+308}$ หมายเหตุสำคัญ: บนบอร์ด Arduino รุ่นเล็ก (เช่น Uno, Nano) ค่า double จะมีความละเอียดเท่ากับ float ทุกประการ แต่บนบอร์ดรุ่นใหญ่ (เช่น Due) double จะให้ความละเอียดที่สูงกว่าจริง ๆ
|
ตัวอย่าง
double highPrecisionValue = 12.3456789; // บน Uno จะมีค่าเท่ากับ float
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("highPrecisionValue = ");
Serial.println(highPrecisionValue); // แสดงผล: 12.35
Serial.print("ขนาดของ double: ");
Serial.print(sizeof(double));
Serial.println(" bytes");
Serial.print("ขนาดของ float: ");
Serial.print(sizeof(float));
Serial.println(" bytes");
Serial.println("----------");
delay(1000); // หน่วงเวลา 1 วินาที
}
ผลลัพธ์
highPrecisionValue = 12.35
ขนาดของ double: 4 bytes
ขนาดของ float: 4 bytes
|
อัปเลเวลการเขียนโปรแกรมของคุณไปอีกขั้น ด้วยการประยุกต์ใช้ตัวแปรเหล่านี้ในโปรเจกต์ Arduino Nano
10. void (ว่างเปล่า)
void เป็นคีย์เวิร์ดที่ใช้ระบุว่าไม่มีการคืนค่าข้อมูลใด ๆ มักเห็นได้ชัดเจนในการประกาศฟังก์ชัน เช่น void setup() หรือ void loop() ซึ่งหมายความว่าฟังก์ชันเหล่านี้จะทำงานตามคำสั่งภายในจนเสร็จสิ้นโดยไม่มีการส่งค่าตัวเลขหรือข้อมูลใด ๆ กลับออกมาให้โปรแกรมส่วนอื่น
|
ตัวอย่าง
void printHello() { // ฟังก์ชันที่สั่งงานอย่างเดียว ไม่มีการส่งค่ากลับ
Serial.println("Hello");
}
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
printHello(); // เรียกใช้ฟังก์ชัน
delay(1000); // หน่วงเวลา 1 วินาที
}
*ผลลัพธ์
Hello
Hello
Hello
...
|
11. arrays (แถวลำดับ)
เป็นโครงสร้างที่ใช้เก็บข้อมูลประเภทเดียวกันหลาย ๆ ค่าไว้ภายใต้ชื่อตัวแปรเดียว โดยใช้ระบบตัวเลขดัชนี (Index Number) เป็นตัวระบุตำแหน่งเพื่อเข้าถึงข้อมูลแต่ละตัว สิ่งสำคัญที่ต้องจำคือลำดับของ array จะเริ่มต้นนับตำแหน่งแรกที่ ศูนย์ (0) เสมอ การใช้ array ช่วยให้การจัดการข้อมูลจำนวนมาก (เช่น ค่าจากเซนเซอร์ 10 ตัว) ทำได้สะดวกผ่านการวน loop
|
ตัวอย่าง
int sensorValues[] = {102, 405, 300, 520}; // เก็บค่าหลายค่าในชื่อเดียว
int firstValue = sensorValues[0]; // ดึงค่าลำดับแรก (102) ออกมา
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("firstValue = ");
Serial.println(firstValue); // แสดงผล: 102
Serial.println("ค่าทั้งหมดใน Array:");
for (int i = 0; i < 4; i++) {
Serial.print("sensorValues[");
Serial.print(i);
Serial.print("] = ");
Serial.println(sensorValues[i]);
}
Serial.println("----------");
delay(2000); // หน่วงเวลา 2 วินาที
}
ผลลัพธ์
firstValue = 102
ค่าทั้งหมดใน Array:
sensorValues[0] = 102
sensorValues[1] = 405
sensorValues[2] = 300
sensorValues[3] = 520
|
12. string (สตริง/ข้อความ)
ในบริบทของ Arduino สตริงคือการนำตัวแปรชนิด char หลาย ๆ ตัวมาเรียงต่อกันเป็นแถวลำดับ (Array of char) เพื่อใช้เก็บข้อความหรือประโยค ตัวอย่างเช่นคำว่า "HELLO" จะถูกเก็บเป็น array ของตัวอักษร H, E, L, L, O ต่อกัน ทำให้เราสามารถจัดการกับข้อความหรือแสดงผลบนหน้าจอ LCD ได้ง่ายขึ้น
|
ตัวอย่าง
char message[] = "Arduino"; // เก็บข้อความในรูปแบบ Array ของ Char
String webMessage = "Hello World"; // ใช้คลาส String (อำนวยความสะดวกเพิ่มขึ้น)
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("message = ");
Serial.println(message); // แสดงผล: Arduino
Serial.print("webMessage = ");
Serial.println(webMessage); // แสดงผล: Hello World
Serial.print("ความยาว message = ");
Serial.println(strlen(message)); // แสดงจำนวนตัวอักษร: 7
Serial.print("ความยาว webMessage = ");
Serial.println(webMessage.length()); // แสดงจำนวนตัวอักษร: 11
Serial.println("----------");
delay(2000); // หน่วงเวลา 2 วินาที
}
ผลลัพธ์
message = Arduino
webMessage = Hello World
ความยาว message = 7
ความยาว webMessage = 11
|
13. pointer (ตัวชี้)
ตัวแปร Arduino ชนิดพิเศษที่ไม่ใช้เก็บค่าข้อมูลโดยตรง แต่ใช้สำหรับเก็บ "ตำแหน่งแอดเดรส (Address)" ในหน่วยความจำที่ข้อมูลนั้นถูกจัดเก็บอยู่ เปรียบเสมือนป้ายบอกทางที่ชี้ไปยังตำแหน่งของตัวแปรตัวอื่น ๆ อีกทีหนึ่ง พอยน์เตอร์มีความสำคัญมากในการเขียนโปรแกรมระดับสูงและการจัดการหน่วยความจำอย่างมีประสิทธิภาพ
|
ตัวอย่าง
int number = 10;
int *p = &number; // p คือ pointer ที่เก็บตำแหน่งของตัวแปร number
void setup() {
Serial.begin(9600); // เริ่มต้น Serial Monitor
}
void loop() {
// แสดงค่าตัวแปร
Serial.print("number = ");
Serial.println(number); // แสดงค่า: 10
Serial.print("ที่อยู่ของ number = ");
Serial.println((unsigned long)&number, HEX); // แสดงที่อยู่หน่วยความจำ
Serial.print("p (ที่อยู่ที่เก็บไว้) = ");
Serial.println((unsigned long)p, HEX); // แสดงที่อยู่ที่ pointer เก็บ
Serial.print("*p (ค่าที่ pointer ชี้ไป) = ");
Serial.println(*p); // แสดงค่าที่ pointer ชี้ไป: 10
Serial.println("----------");
delay(2000); // หน่วงเวลา 2 วินาที
}
ผลลัพธ์
number = 10
ที่อยู่ของ number = 1A2
p (ที่อยู่ที่เก็บไว้) = 1A2
*p (ค่าที่ pointer ชี้ไป) = 10
|
ตัวแปร Arduino มีคุณสมบัติอะไรบ้าง
คุณสมบัติของตัวแปร Arduino ไม่ได้เป็นเพียงแค่ชื่อเรียก แต่มีองค์ประกอบสำคัญ 3 ประการที่โปรแกรมเมอร์ต้องจำให้ขึ้นใจ
-
Data Type (ชนิดข้อมูล): เป็นการบอกคอมไพเลอร์ว่าเราจะเก็บข้อมูลประเภทไหน และต้องสำรองพื้นที่ในหน่วยความจำเท่าไหร่
-
Variable Name (ชื่อตัวแปร): ต้องเป็นชื่อที่ไม่ซ้ำกับคำสงวน (Reserved Words) และควรสื่อความหมาย เช่น sensorValue หรือ ledPin
-
Scope (ขอบเขตของตัวแปร): ตัวแปรจะมีอายุการใช้งานตามตำแหน่งที่มันอยู่ (Global หรือ Local) ซึ่งส่งผลต่อการเรียกใช้งานจาก Arduino ฟังก์ชันต่าง ๆ
-
Initialization (การกำหนดค่าเริ่มต้น): การให้ค่าตั้งต้นแก่ตัวแปรเพื่อป้องกันการดึงค่าขยะ (Garbage Value) จากหน่วยความจำมาใช้งาน
เปลี่ยนตัวเลขในโค้ดให้เป็นค่าจริงจากโลกภายนอก เรียนรู้วิธีการเชื่อมต่อและอ่านค่าในบทความ Arduino Sensor คลิกเลย
ตัวอย่างการประกาศตัวแปร Arduino
การประกาศตัวแปร Arduino มีรูปแบบมาตรฐานคือ ชนิดตัวแปร ชื่อตัวแปร = ค่าเริ่มต้น; ดังตัวอย่างต่อไปนี้
C++
int ledPin = 13; // ประกาศตัวแปรชนิดจำนวนเต็ม ชื่อ ledPin ให้ค่าเท่ากับ 13
float temperature = 25.5; // ประกาศตัวแปรทศนิยมเพื่อเก็บค่าอุณหภูมิ
boolean status = false; // ประกาศสถานะเปิด/ปิด
char unit = 'C'; // เก็บตัวอักษร C (Celsius)
สามารถใช้ตัวแปร Arduino ได้อย่างไร
การใช้ตัวแปรใน Arduino เริ่มต้นจากการ Declare (ประกาศ) ไว้ที่ส่วนบนสุดของโค้ด (Global) หรือภายในฟังก์ชัน (Local) จากนั้นจึงนำไป Assign (กำหนดค่า) หรือ Process (ประมวลผล) ในส่วนของ void setup() และ void loop()
ขั้นตอนการใช้งาน
-
กำหนดค่าคงที่: มักใช้ const นำหน้าสำหรับขา Pin ต่าง ๆ เพื่อป้องกันการเผลอเปลี่ยนค่าในโค้ด
-
รับค่าจากเซนเซอร์: ใช้ตัวแปรเก็บค่าที่อ่านได้ เช่น val = analogRead(A0);
-
คำนวณผล: นำตัวแปรมาบวก ลบ คูณ หาร เพื่อหาค่าที่ต้องการ
-
แสดงผล: ส่งค่าในตัวแปรออกไปทาง Serial Monitor หรือหน้าจอ LCD
คำถามที่พบได้บ่อย (FAQs)
ตัวแปร Global Variable กับ Local Variable ต่างกันอย่างไร?
Global ประกาศนอกฟังก์ชันและใช้ได้ทุกที่ในโค้ด ส่วน Local ประกาศในฟังก์ชันและใช้ได้เฉพาะภายในเครื่องหมาย { } ของฟังก์ชันนั้นเท่านั้น
ทำไมควรใช้ const นำหน้าตัวแปร?
เพื่อให้ตัวแปร Arduino นั้นกลายเป็นค่าคงที่ที่แก้ไขไม่ได้ ช่วยป้องกันบัคจากการเขียนค่าทับซ้ำและช่วยให้คอมไพเลอร์เพิ่มประสิทธิภาพของโค้ด
เขียนโค้ดให้โปรด้วยตัวแปร Arduino พร้อมเลือกซื้ออุปกรณ์แท้ที่ Global Byte
การเข้าใจเรื่องตัวแปร Arduino เป็นรากฐานสำคัญที่เปลี่ยนจากผู้เริ่มต้นให้กลายเป็นนักพัฒนาที่มีทักษะ การเลือกใช้ชนิดข้อมูลที่เหมาะสมอย่าง byte หรือ int ไม่เพียงแต่ทำให้โค้ดทำงานได้ถูกต้อง แต่ยังช่วยเพิ่มประสิทธิภาพสูงสุดให้กับบอร์ดไมโครคอนโทรลเลอร์ของคุณในการจัดการข้อมูลที่ซับซ้อน
หากคุณกำลังมองหาแหล่งซื้ออุปกรณ์สำหรับทำโปรเจค Arduino Global Byte เป็นตัวแทนจำหน่ายที่ถูกรับรองอย่างเป็นทางการ (Approved Reseller) ในเครือข่าย Raspberry Pi ทำให้มั่นใจได้ว่าเป็นสินค้าแท้ 100% พร้อมการรับประกัน นอกจากนี้ยังเป็นแหล่งรวมอุปกรณ์อิเล็กทรอนิกส์แบบครบวงจร ตั้งแต่ Raspberry Pi, ESP32, โมดูลและเซนเซอร์, Switch Hub, Power Supply, เคส ไปจนถึงบริการให้คำปรึกษาและพัฒนาโซลูชันต้นแบบ ช่วยให้คุณพร้อมเริ่มโปรเจคอย่างมั่นใจได้ทันที
จากไอเดีย สู่ไลน์ผลิต—ครบจบที่ GlobalByte
ช่องทางการติดต่อ : http://openlink.co/globalbyte
แท็ก
Arduino
