Arduino - คู่มือฉบับย่อ

Arduino เป็นแพลตฟอร์มต้นแบบ (โอเพ่นซอร์ส) ที่ใช้ฮาร์ดแวร์และซอฟต์แวร์ที่ใช้งานง่าย ประกอบด้วยแผงวงจรซึ่งสามารถตั้งโปรแกรมได้ (เรียกว่าไมโครคอนโทรลเลอร์) และซอฟต์แวร์สำเร็จรูปที่เรียกว่า Arduino IDE (Integrated Development Environment) ซึ่งใช้ในการเขียนและอัปโหลดโค้ดคอมพิวเตอร์ไปยังบอร์ดทางกายภาพ

คุณสมบัติที่สำคัญคือ -

• บอร์ด Arduino สามารถอ่านสัญญาณอินพุตแบบอะนาล็อกหรือดิจิทัลจากเซ็นเซอร์ต่างๆและเปลี่ยนเป็นเอาต์พุตเช่นการเปิดใช้งานมอเตอร์การเปิด / ปิด LED เชื่อมต่อกับคลาวด์และการทำงานอื่น ๆ

• คุณสามารถควบคุมการทำงานของบอร์ดได้โดยส่งชุดคำสั่งไปยังไมโครคอนโทรลเลอร์บนบอร์ดผ่าน Arduino IDE (เรียกว่าการอัปโหลดซอฟต์แวร์)

• ซึ่งแตกต่างจากแผงวงจรที่ตั้งโปรแกรมได้ก่อนหน้านี้ส่วนใหญ่ Arduino ไม่จำเป็นต้องมีฮาร์ดแวร์เพิ่มเติม (เรียกว่าโปรแกรมเมอร์) เพื่อโหลดรหัสใหม่ลงบนบอร์ด คุณสามารถใช้สาย USB

• นอกจากนี้ Arduino IDE ยังใช้ C ++ เวอร์ชันที่เรียบง่ายทำให้เรียนรู้การเขียนโปรแกรมได้ง่ายขึ้น

• สุดท้าย Arduino จัดเตรียมฟอร์มแฟคเตอร์มาตรฐานที่แบ่งการทำงานของไมโครคอนโทรลเลอร์ออกเป็นแพ็คเกจที่เข้าถึงได้ง่ายขึ้น

ประเภทบอร์ด

มีบอร์ด Arduino หลากหลายชนิดขึ้นอยู่กับไมโครคอนโทรลเลอร์ที่ใช้ อย่างไรก็ตามบอร์ด Arduino ทั้งหมดมีสิ่งหนึ่งที่เหมือนกันนั่นคือโปรแกรมผ่าน Arduino IDE

ความแตกต่างจะขึ้นอยู่กับจำนวนอินพุตและเอาต์พุต (จำนวนเซ็นเซอร์ไฟ LED และปุ่มที่คุณสามารถใช้บนบอร์ดเดียว) ความเร็วแรงดันไฟฟ้าในการทำงานฟอร์มแฟกเตอร์เป็นต้นบอร์ดบางตัวได้รับการออกแบบให้ฝังตัวและไม่มีการตั้งโปรแกรม อินเทอร์เฟซ (ฮาร์ดแวร์) ซึ่งคุณจะต้องซื้อแยกต่างหาก บางรุ่นสามารถทำงานได้โดยตรงจากแบตเตอรี่ 3.7V บางรุ่นต้องใช้อย่างน้อย 5V

นี่คือรายการบอร์ด Arduino ต่างๆที่มีให้

Arduino boards based on ATMEGA328 microcontroller

ชื่อคณะกรรมการ	โวลต์ปฏิบัติการ	ความเร็วนาฬิกา	ดิจิตอล i / o	อินพุตแบบอนาล็อก	PWM	UART	อินเตอร์เฟซการเขียนโปรแกรม
Arduino Uno R3	5V	16MHz	14	6	6	1	USB ผ่าน ATMega16U2
Arduino Uno R3 SMD	5V	16MHz	14	6	6	1	USB ผ่าน ATMega16U2
คณะกรรมการสีแดง	5V	16MHz	14	6	6	1	USB ผ่าน FTDI
Arduino Pro 3.3v / 8 MHz	3.3V	8MHz	14	6	6	1	ส่วนหัวที่เข้ากันได้กับ FTDI
Arduino Pro 5V / 16MHz	5V	16MHz	14	6	6	1	ส่วนหัวที่เข้ากันได้กับ FTDI
Arduino mini 05	5V	16MHz	14	8	6	1	ส่วนหัวที่เข้ากันได้กับ FTDI
Arduino Pro mini 3.3v / 8mhz	3.3V	8MHz	14	8	6	1	ส่วนหัวที่เข้ากันได้กับ FTDI
Arduino Pro mini 5v / 16mhz	5V	16MHz	14	8	6	1	ส่วนหัวที่เข้ากันได้กับ FTDI
Arduino Ethernet	5V	16MHz	14	6	6	1	ส่วนหัวที่เข้ากันได้กับ FTDI
Arduino Fio	3.3V	8MHz	14	8	6	1	ส่วนหัวที่เข้ากันได้กับ FTDI
บอร์ดหลัก LilyPad Arduino 328	3.3V	8MHz	14	6	6	1	ส่วนหัวที่เข้ากันได้กับ FTDI
LilyPad Arduino บอร์ดง่ายๆ	3.3V	8MHz	9	4	5	0	ส่วนหัวที่เข้ากันได้กับ FTDI

Arduino boards based on ATMEGA32u4 microcontroller

ชื่อคณะกรรมการ	โวลต์ปฏิบัติการ	ความเร็วนาฬิกา	ดิจิตอล i / o	อินพุตแบบอนาล็อก	PWM	UART	อินเตอร์เฟซการเขียนโปรแกรม
Arduino Leonardo	5V	16MHz	20	12	7	1	USB ดั้งเดิม
โปรไมโคร 5V / 16MHz	5V	16MHz	14	6	6	1	USB ดั้งเดิม
โปรไมโคร 3.3V / 8MHz	5V	16MHz	14	6	6	1	USB ดั้งเดิม
LilyPad Arduino USB	3.3V	8MHz	14	6	6	1	USB ดั้งเดิม

Arduino boards based on ATMEGA2560 microcontroller

ชื่อคณะกรรมการ	โวลต์ปฏิบัติการ	ความเร็วนาฬิกา	ดิจิตอล i / o	อินพุตแบบอนาล็อก	PWM	UART	อินเตอร์เฟซการเขียนโปรแกรม
Arduino Mega 2560 R3	5V	16MHz	54	16	14	4	USB ผ่าน ATMega16U2B
เมกะโปร 3.3V	3.3V	8MHz	54	16	14	4	ส่วนหัวที่เข้ากันได้กับ FTDI
เมกะโปร 5V	5V	16MHz	54	16	14	4	ส่วนหัวที่เข้ากันได้กับ FTDI
Mega Pro Mini 3.3V	3.3V	8MHz	54	16	14	4	ส่วนหัวที่เข้ากันได้กับ FTDI

Arduino boards based on AT91SAM3X8E microcontroller

ชื่อคณะกรรมการ	โวลต์ปฏิบัติการ	ความเร็วนาฬิกา	ดิจิตอล i / o	อินพุตแบบอนาล็อก	PWM	UART	อินเตอร์เฟซการเขียนโปรแกรม
Arduino Mega 2560 R3	3.3V	84MHz	54	12	12	4	USB เนทีฟ

ในบทนี้เราจะเรียนรู้เกี่ยวกับส่วนประกอบต่างๆบนบอร์ด Arduino เราจะศึกษาบอร์ด Arduino UNO เนื่องจากเป็นบอร์ดที่ได้รับความนิยมสูงสุดในตระกูลบอร์ด Arduino นอกจากนี้ยังเป็นบอร์ดที่ดีที่สุดในการเริ่มต้นใช้งานอุปกรณ์อิเล็กทรอนิกส์และการเข้ารหัส บอร์ดบางตัวดูแตกต่างจากที่ระบุด้านล่างเล็กน้อย แต่ Arduinos ส่วนใหญ่มีส่วนประกอบเหล่านี้ส่วนใหญ่เหมือนกัน

	Power USB บอร์ด Arduino สามารถขับเคลื่อนโดยใช้สาย USB จากคอมพิวเตอร์ของคุณ สิ่งที่คุณต้องทำคือเชื่อมต่อสาย USB เข้ากับการเชื่อมต่อ USB (1)
	Power (Barrel Jack) บอร์ด Arduino สามารถใช้พลังงานจากแหล่งจ่ายไฟ AC ได้โดยตรงโดยเชื่อมต่อกับ Barrel Jack (2)
	Voltage Regulator หน้าที่ของตัวควบคุมแรงดันไฟฟ้าคือการควบคุมแรงดันไฟฟ้าที่กำหนดให้กับบอร์ด Arduino และทำให้แรงดันไฟฟ้ากระแสตรงที่ใช้โดยโปรเซสเซอร์และองค์ประกอบอื่น ๆ คงที่
	Crystal Oscillator คริสตัลออสซิลเลเตอร์ช่วย Arduino ในการจัดการกับปัญหาด้านเวลา Arduino คำนวณเวลาอย่างไร? คำตอบคือโดยใช้คริสตัลออสซิลเลเตอร์ ตัวเลขที่พิมพ์อยู่ด้านบนของคริสตัล Arduino คือ 16.000H9H บอกเราว่าความถี่ 16,000,000 เฮิรตซ์หรือ 16 เมกะเฮิรตซ์
	Arduino Reset คุณสามารถรีเซ็ตบอร์ด Arduino ของคุณได้เช่นเริ่มโปรแกรมของคุณตั้งแต่เริ่มต้น คุณสามารถรีเซ็ตบอร์ด UNO ได้สองวิธี ขั้นแรกโดยใช้ปุ่มรีเซ็ต (17) บนบอร์ด ประการที่สองคุณสามารถเชื่อมต่อปุ่มรีเซ็ตภายนอกกับขา Arduino ที่มีข้อความ RESET (5)
	Pins (3.3, 5, GND, Vin) 3.3V (6) - จ่าย 3.3 โวลต์เอาท์พุท 5V (7) - จ่าย 5 โวลต์เอาท์พุท ส่วนประกอบส่วนใหญ่ที่ใช้กับบอร์ด Arduino ทำงานได้ดีกับ 3.3 โวลต์และ 5 โวลต์ GND (8) (กราวด์) - มีพิน GND หลายตัวบน Arduino ซึ่งสามารถใช้ต่อกราวด์วงจรของคุณได้ Vin (9) - พินนี้ยังสามารถใช้เพื่อจ่ายไฟให้กับบอร์ด Arduino จากแหล่งจ่ายไฟภายนอกเช่นแหล่งจ่ายไฟ AC
	Analog pins บอร์ด Arduino UNO มีหมุดอินพุตแบบอะนาล็อกหกตัว A0 ถึง A5 หมุดเหล่านี้สามารถอ่านสัญญาณจากเซ็นเซอร์อนาล็อกเช่นเซ็นเซอร์ความชื้นหรือเซ็นเซอร์อุณหภูมิและแปลงเป็นค่าดิจิทัลที่ไมโครโปรเซสเซอร์อ่านได้
	Main microcontroller บอร์ด Arduino แต่ละตัวมีไมโครคอนโทรลเลอร์ของตัวเอง (11) คุณสามารถถือว่ามันเป็นสมองของกระดานของคุณ IC หลัก (วงจรรวม) บน Arduino นั้นแตกต่างจากบอร์ดถึงบอร์ดเล็กน้อย ไมโครคอนโทรลเลอร์มักเป็นของ บริษัท ATMEL คุณต้องรู้ว่าบอร์ดของคุณมี IC อะไรก่อนที่จะโหลดโปรแกรมใหม่จาก Arduino IDE ข้อมูลนี้อยู่ที่ด้านบนของ IC สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับโครงสร้าง IC และฟังก์ชันคุณสามารถอ้างอิงได้จากเอกสารข้อมูล
	ICSP pin ส่วนใหญ่ ICSP (12) เป็น AVR ซึ่งเป็นส่วนหัวการเขียนโปรแกรมขนาดเล็กสำหรับ Arduino ซึ่งประกอบด้วย MOSI, MISO, SCK, RESET, VCC และ GND มักเรียกกันว่า SPI (Serial Peripheral Interface) ซึ่งถือได้ว่าเป็นการ "ขยาย" ของเอาต์พุต จริงๆแล้วคุณกำลังพันอุปกรณ์เอาท์พุตให้กับต้นแบบของบัส SPI
	Power LED indicator LED นี้ควรสว่างขึ้นเมื่อคุณเสียบ Arduino เข้ากับแหล่งจ่ายไฟเพื่อระบุว่าบอร์ดของคุณเปิดเครื่องอย่างถูกต้อง หากไฟนี้ไม่ติดแสดงว่ามีบางอย่างผิดปกติกับการเชื่อมต่อ
	TX and RX LEDs บนกระดานของคุณคุณจะพบป้ายกำกับสองป้าย: TX (ส่ง) และ RX (รับ) ปรากฏในสองตำแหน่งบนบอร์ด Arduino UNO อันดับแรกที่พินดิจิทัล 0 และ 1 เพื่อระบุพินที่รับผิดชอบในการสื่อสารแบบอนุกรม ประการที่สอง TX และ RX นำ (13) ไฟ LED TX กะพริบด้วยความเร็วที่แตกต่างกันในขณะที่ส่งข้อมูลอนุกรม ความเร็วของการกะพริบขึ้นอยู่กับอัตราบอดที่บอร์ดใช้ RX กะพริบระหว่างกระบวนการรับ
	Digital I/O บอร์ด Arduino UNO มีพิน I / O ดิจิทัล 14 พิน (15) (ซึ่ง 6 พินให้เอาต์พุต PWM (Pulse Width Modulation) พินเหล่านี้สามารถกำหนดค่าให้ทำงานเป็นพินดิจิทัลอินพุตเพื่ออ่านค่าลอจิก (0 หรือ 1) หรือเป็นดิจิทัล พินเอาต์พุตเพื่อขับเคลื่อนโมดูลต่างๆเช่น LED รีเลย์ ฯลฯ สามารถใช้หมุดที่มีข้อความ "~" เพื่อสร้าง PWM
	AREF AREF ย่อมาจาก Analog Reference บางครั้งใช้เพื่อกำหนดแรงดันอ้างอิงภายนอก (ระหว่าง 0 ถึง 5 โวลต์) เป็นขีด จำกัด บนสำหรับพินอินพุตแบบอะนาล็อก

หลังจากเรียนรู้เกี่ยวกับส่วนหลักของบอร์ด Arduino UNO แล้วเราก็พร้อมที่จะเรียนรู้วิธีตั้งค่า Arduino IDE เมื่อเราเรียนรู้สิ่งนี้แล้วเราก็พร้อมที่จะอัปโหลดโปรแกรมของเราบนบอร์ด Arduino

ในส่วนนี้เราจะได้เรียนรู้ในขั้นตอนง่ายๆวิธีการตั้งค่า Arduino IDE บนคอมพิวเตอร์ของเราและเตรียมบอร์ดเพื่อรับโปรแกรมผ่านสาย USB

Step 1- ก่อนอื่นคุณต้องมีบอร์ด Arduino ของคุณ (คุณสามารถเลือกบอร์ดที่คุณชื่นชอบได้) และสาย USB ในกรณีที่คุณใช้ Arduino UNO, Arduino Duemilanove, Nano, Arduino Mega 2560 หรือ Diecimila คุณจะต้องใช้สาย USB มาตรฐาน (ปลั๊ก A ต่อปลั๊ก B) ซึ่งเป็นชนิดที่คุณจะเชื่อมต่อกับเครื่องพิมพ์ USB ดังที่แสดงในภาพต่อไปนี้

ในกรณีที่คุณใช้ Arduino Nano คุณจะต้องใช้สาย A ถึง Mini-B แทนดังที่แสดงในภาพต่อไปนี้

Step 2 − Download Arduino IDE Software.

คุณสามารถรับ Arduino IDE เวอร์ชันต่างๆได้จากหน้าดาวน์โหลดบนเว็บไซต์ทางการของ Arduino คุณต้องเลือกซอฟต์แวร์ของคุณซึ่งเข้ากันได้กับระบบปฏิบัติการของคุณ (Windows, IOS หรือ Linux) หลังจากดาวน์โหลดไฟล์เสร็จแล้วให้ทำการแตกไฟล์

Step 3 − Power up your board.

Arduino Uno, Mega, Duemilanove และ Arduino Nano จะดึงพลังงานจากการเชื่อมต่อ USB ไปยังคอมพิวเตอร์หรือแหล่งจ่ายไฟภายนอกโดยอัตโนมัติ หากคุณใช้ Arduino Diecimila คุณต้องตรวจสอบให้แน่ใจว่าบอร์ดได้รับการกำหนดค่าให้ดึงพลังงานจากการเชื่อมต่อ USB แหล่งจ่ายไฟจะถูกเลือกด้วยจัมเปอร์ซึ่งเป็นพลาสติกชิ้นเล็ก ๆ ที่พอดีกับสองในสามพินระหว่าง USB และแจ็คเพาเวอร์ ตรวจสอบว่าอยู่บนหมุดสองตัวที่ใกล้กับพอร์ต USB มากที่สุด

เชื่อมต่อบอร์ด Arduino เข้ากับคอมพิวเตอร์ของคุณโดยใช้สาย USB ไฟ LED สีเขียว (ที่มีข้อความ PWR) ควรติดสว่าง

Step 4 − Launch Arduino IDE.

หลังจากดาวน์โหลดซอฟต์แวร์ Arduino IDE แล้วคุณต้องเปิดเครื่องรูดโฟลเดอร์ ภายในโฟลเดอร์คุณจะพบไอคอนแอปพลิเคชันที่มีป้ายกำกับอินฟินิตี้ (application.exe) ดับเบิลคลิกที่ไอคอนเพื่อเริ่ม IDE

Step 5 − Open your first project.

เมื่อซอฟต์แวร์เริ่มทำงานคุณมีสองทางเลือก -

• สร้างโครงการใหม่
• เปิดตัวอย่างโครงการที่มีอยู่

ในการสร้างโปรเจ็กต์ใหม่ให้เลือกไฟล์→ New.

ในการเปิดตัวอย่างโปรเจ็กต์ที่มีอยู่ให้เลือกไฟล์→ตัวอย่าง→พื้นฐาน→กะพริบ

เรากำลังเลือกเพียงหนึ่งในตัวอย่างที่มีชื่อ Blink. จะเปิดและปิด LED โดยมีการหน่วงเวลา คุณสามารถเลือกตัวอย่างอื่น ๆ จากรายการ

Step 6 − Select your Arduino board.

เพื่อหลีกเลี่ยงข้อผิดพลาดขณะอัปโหลดโปรแกรมของคุณไปยังบอร์ดคุณต้องเลือกชื่อบอร์ด Arduino ที่ถูกต้องซึ่งตรงกับบอร์ดที่เชื่อมต่อกับคอมพิวเตอร์ของคุณ

ไปที่ Tools → Board แล้วเลือกบอร์ดของคุณ

ที่นี่เราได้เลือกบอร์ด Arduino Uno ตามบทช่วยสอนของเรา แต่คุณต้องเลือกชื่อที่ตรงกับบอร์ดที่คุณใช้

Step 7 − Select your serial port.

เลือกอุปกรณ์อนุกรมของบอร์ด Arduino ไปที่Tools → Serial Portเมนู. ซึ่งมีแนวโน้มว่าจะเป็น COM3 หรือสูงกว่า (โดยปกติ COM1 และ COM2 จะสงวนไว้สำหรับพอร์ตอนุกรมของฮาร์ดแวร์) หากต้องการทราบคุณสามารถยกเลิกการเชื่อมต่อบอร์ด Arduino ของคุณและเปิดเมนูอีกครั้งรายการที่หายไปควรเป็นของบอร์ด Arduino เชื่อมต่อบอร์ดอีกครั้งและเลือกพอร์ตอนุกรมนั้น

Step 8 − Upload the program to your board.

ก่อนที่จะอธิบายว่าเราสามารถอัปโหลดโปรแกรมของเราไปยังบอร์ดได้อย่างไรเราต้องสาธิตการทำงานของสัญลักษณ์แต่ละตัวที่ปรากฏในแถบเครื่องมือ Arduino IDE

A - ใช้เพื่อตรวจสอบว่ามีข้อผิดพลาดในการคอมไพล์หรือไม่

B - ใช้ในการอัพโหลดโปรแกรมไปยังบอร์ด Arduino

C - ทางลัดที่ใช้ในการสร้างร่างใหม่

D - ใช้เพื่อเปิดหนึ่งในร่างตัวอย่างโดยตรง

E - ใช้เพื่อบันทึกร่างของคุณ

F - มอนิเตอร์แบบอนุกรมใช้ในการรับข้อมูลอนุกรมจากบอร์ดและส่งข้อมูลอนุกรมไปยังบอร์ด

ตอนนี้เพียงคลิกปุ่ม "อัปโหลด" ในสภาพแวดล้อม รอสักครู่ คุณจะเห็นไฟ LED RX และ TX บนบอร์ดกะพริบ หากการอัปโหลดสำเร็จข้อความ "เสร็จสิ้นการอัปโหลด" จะปรากฏในแถบสถานะ

Note - หากคุณมี Arduino Mini, NG หรือบอร์ดอื่น ๆ คุณต้องกดปุ่มรีเซ็ตทางกายภาพบนบอร์ดทันทีก่อนที่จะคลิกปุ่มอัปโหลดบนซอฟต์แวร์ Arduino

ในบทนี้เราจะศึกษาเชิงลึกโครงสร้างโปรแกรม Arduino และเราจะเรียนรู้คำศัพท์ใหม่ ๆ ที่ใช้ในโลก Arduino ซอฟต์แวร์ Arduino เป็นโอเพ่นซอร์ส ซอร์สโค้ดสำหรับสภาพแวดล้อม Java ถูกเผยแพร่ภายใต้ GPL และไลบรารีไมโครคอนโทรลเลอร์ C / C ++ อยู่ภายใต้ LGPL

Sketch - คำศัพท์ใหม่ตัวแรกคือโปรแกรม Arduino ที่เรียกว่า“sketch”.

โครงสร้าง

โปรแกรม Arduino สามารถแบ่งออกเป็นสามส่วนหลัก: Structure, Values (ตัวแปรและค่าคงที่) และ Functions. ในบทช่วยสอนนี้เราจะเรียนรู้เกี่ยวกับโปรแกรมซอฟต์แวร์ Arduino ทีละขั้นตอนและวิธีการเขียนโปรแกรมโดยไม่มีข้อผิดพลาดทางไวยากรณ์หรือการคอมไพล์

เริ่มต้นด้วย Structure. โครงสร้างซอฟต์แวร์ประกอบด้วยสองหน้าที่หลัก -

• ฟังก์ชัน Setup ()
• ฟังก์ชัน Loop ()

Void setup ( ) {

}

• PURPOSE - setup()ฟังก์ชันถูกเรียกใช้เมื่อร่างเริ่มต้น ใช้เพื่อเริ่มต้นตัวแปรโหมดพินเริ่มใช้ไลบรารี ฯลฯ ฟังก์ชันการตั้งค่าจะทำงานเพียงครั้งเดียวหลังจากเปิดเครื่องหรือรีเซ็ตบอร์ด Arduino แต่ละครั้ง

• INPUT - -

• OUTPUT - -

• RETURN - -

Void Loop ( ) {

}

• PURPOSE - หลังจากสร้างไฟล์ setup() ซึ่งเริ่มต้นและตั้งค่าเริ่มต้นคือ loop()ฟังก์ชั่นทำสิ่งที่ชื่อแนะนำอย่างแม่นยำและวนซ้ำติดต่อกันทำให้โปรแกรมของคุณเปลี่ยนแปลงและตอบสนอง ใช้เพื่อควบคุมบอร์ด Arduino อย่างแข็งขัน

• INPUT - -

• OUTPUT - -

• RETURN - -

ชนิดข้อมูลใน C หมายถึงระบบที่กว้างขวางที่ใช้สำหรับการประกาศตัวแปรหรือฟังก์ชันประเภทต่างๆ ประเภทของตัวแปรจะกำหนดว่ามีพื้นที่ว่างเท่าใดในหน่วยเก็บข้อมูลและวิธีตีความรูปแบบบิตที่จัดเก็บ

ตารางต่อไปนี้แสดงประเภทข้อมูลทั้งหมดที่คุณจะใช้ระหว่างการเขียนโปรแกรม Arduino

เป็นโมฆะ	บูลีน	ถ่าน	ถ่านที่ไม่ได้ลงนาม	ไบต์	int	int ที่ไม่ได้ลงนาม	คำ
ยาว	ไม่ได้ลงนามยาว	สั้น	ลอย	สองเท่า	อาร์เรย์	อาร์เรย์สตริงถ่าน	สตริงวัตถุ

เป็นโมฆะ

คีย์เวิร์ดโมฆะใช้ในการประกาศฟังก์ชันเท่านั้น แสดงว่าฟังก์ชันนี้คาดว่าจะไม่ส่งคืนข้อมูลไปยังฟังก์ชันที่ถูกเรียกใช้

ตัวอย่าง

Void Loop ( ) {
   // rest of the code
}

บูลีน

บูลีนมีค่าหนึ่งในสองค่าเป็นจริงหรือเท็จ ตัวแปรบูลีนแต่ละตัวใช้หน่วยความจำหนึ่งไบต์

ตัวอย่าง

boolean val = false ; // declaration of variable with type boolean and initialize it with false
boolean state = true ; // declaration of variable with type boolean and initialize it with true

ถ่าน

ชนิดข้อมูลที่ใช้หน่วยความจำหนึ่งไบต์ที่เก็บค่าอักขระ อักษรตัวอักษรเขียนด้วยเครื่องหมายคำพูดเดียวดังนี้ 'A' และสำหรับอักขระหลายตัวสตริงจะใช้เครื่องหมายคำพูดคู่: "ABC"

อย่างไรก็ตามอักขระจะถูกจัดเก็บเป็นตัวเลข คุณสามารถดูการเข้ารหัสเฉพาะในแผนภูมิ ASCII ซึ่งหมายความว่าเป็นไปได้ที่จะทำการคำนวณทางคณิตศาสตร์กับอักขระซึ่งใช้ค่า ASCII ของอักขระ ตัวอย่างเช่น 'A' + 1 มีค่า 66 เนื่องจากค่า ASCII ของอักษรตัวใหญ่ A คือ 65

ตัวอย่าง

Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with character 97

ถ่านที่ไม่ได้ลงนาม

Unsigned charเป็นชนิดข้อมูลที่ไม่ได้ลงชื่อซึ่งใช้หน่วยความจำหนึ่งไบต์ ชนิดข้อมูลถ่านที่ไม่ได้ลงนามจะเข้ารหัสตัวเลขตั้งแต่ 0 ถึง 255

ตัวอย่าง

Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y

ไบต์

ไบต์เก็บหมายเลข 8 บิตที่ไม่ได้ลงชื่อตั้งแต่ 0 ถึง 255

ตัวอย่าง

byte m = 25 ;//declaration of variable with type byte and initialize it with 25

int

จำนวนเต็มเป็นชนิดข้อมูลหลักสำหรับการจัดเก็บตัวเลข int เก็บค่า 16 บิต (2 ไบต์) ค่านี้ให้ผลตั้งแต่ -32,768 ถึง 32,767 (ค่าต่ำสุด -2 ^ 15 และค่าสูงสุด (2 ^ 15) - 1)

intขนาดแตกต่างกันไปในแต่ละบอร์ด ใน Arduino Due ตัวอย่างเช่นไฟล์intเก็บค่า 32 บิต (4 ไบต์) สิ่งนี้ให้ผลตั้งแต่ -2,147,483,648 ถึง 2,147,483,647 (ค่าต่ำสุด -2 ^ 31 และค่าสูงสุด (2 ^ 31) - 1)

ตัวอย่าง

int counter = 32 ;// declaration of variable with type int and initialize it with 32

int ที่ไม่ได้ลงนาม

ints ที่ไม่ได้ลงนาม (จำนวนเต็มที่ไม่ได้ลงนาม) เหมือนกับ int ในลักษณะที่เก็บค่า 2 ไบต์ อย่างไรก็ตามแทนที่จะเก็บจำนวนลบ แต่จะเก็บเฉพาะค่าบวกโดยให้ช่วงที่มีประโยชน์ตั้งแต่ 0 ถึง 65,535 (2 ^ 16) - 1) Due เก็บค่า 4 ไบต์ (32 บิต) ตั้งแต่ 0 ถึง 4,294,967,295 (2 ^ 32 - 1)

ตัวอย่าง

Unsigned int counter = 60 ; // declaration of variable with 
   type unsigned int and initialize it with 60

คำ

บน Uno และบอร์ดอื่น ๆ ที่ใช้ ATMEGA word จะจัดเก็บหมายเลขที่ไม่ได้ลงชื่อไว้ 16 บิต ใน Due และ Zero จะเก็บหมายเลข 32 บิตที่ไม่ได้ลงนาม

ตัวอย่าง

word w = 1000 ;//declaration of variable with type word and initialize it with 1000

ยาว

ตัวแปรแบบยาวคือตัวแปรขนาดขยายสำหรับการจัดเก็บตัวเลขและเก็บ 32 บิต (4 ไบต์) ตั้งแต่ -2,147,483,648 ถึง 2,147,483,647

ตัวอย่าง

Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346

ไม่ได้ลงนามยาว

ตัวแปรแบบยาวที่ไม่ได้ลงชื่อเป็นตัวแปรขนาดขยายสำหรับการจัดเก็บตัวเลขและเก็บ 32 บิต (4 ไบต์) ซึ่งแตกต่างจาก longs มาตรฐาน longs ที่ไม่ได้ลงนามจะไม่เก็บตัวเลขที่เป็นลบทำให้มีช่วงตั้งแต่ 0 ถึง 4,294,967,295 (2 ^ 32 - 1)

ตัวอย่าง

Unsigned Long velocity = 101006 ;// declaration of variable with 
   type Unsigned Long and initialize it with 101006

สั้น

ย่อคือชนิดข้อมูล 16 บิต ใน Arduinos ทั้งหมด (ใช้ ATMega และ ARM) แบบย่อจะเก็บค่า 16 บิต (2 ไบต์) ค่านี้ให้ผลตั้งแต่ -32,768 ถึง 32,767 (ค่าต่ำสุด -2 ^ 15 และค่าสูงสุด (2 ^ 15) - 1)

ตัวอย่าง

short val = 13 ;//declaration of variable with type short and initialize it with 13

ลอย

ชนิดข้อมูลสำหรับตัวเลขทศนิยมคือตัวเลขที่มีจุดทศนิยม ตัวเลขทศนิยมมักใช้เพื่อประมาณค่าอะนาล็อกและค่าต่อเนื่องเนื่องจากมีความละเอียดมากกว่าจำนวนเต็ม

ตัวเลขทศนิยมอาจมีขนาดใหญ่ถึง 3.4028235E + 38 และต่ำสุดถึง -3.4028235E + 38 ข้อมูลเหล่านี้จะถูกจัดเก็บเป็นข้อมูล 32 บิต (4 ไบต์)

ตัวอย่าง

float num = 1.352;//declaration of variable with type float and initialize it with 1.352

สองเท่า

บน Uno และบอร์ดที่ใช้ ATMEGA อื่น ๆ เลขทศนิยมที่มีความแม่นยำสองเท่าจะมีพื้นที่สี่ไบต์ นั่นคือการใช้งานสองครั้งจะเหมือนกับการลอยตัวโดยไม่มีการเพิ่มความแม่นยำ ใน Arduino Due คู่มีความแม่นยำ 8 ไบต์ (64 บิต)

ตัวอย่าง

double num = 45.352 ;// declaration of variable with type double and initialize it with 45.352

ก่อนที่เราจะเริ่มอธิบายประเภทตัวแปรเรื่องที่สำคัญมากที่เราต้องตรวจสอบให้แน่ใจคุณเข้าใจอย่างถ่องแท้เรียกว่า variable scope.

Variable Scope คืออะไร?

ตัวแปรในการเขียนโปรแกรมภาษาซีซึ่ง Arduino ใช้มีคุณสมบัติที่เรียกว่าขอบเขต ขอบเขตคือพื้นที่ของโปรแกรมและมีสามตำแหน่งที่สามารถประกาศตัวแปรได้ พวกเขาคือ -

• ภายในฟังก์ชันหรือบล็อกซึ่งเรียกว่า local variables.
• ในนิยามของฟังก์ชันพารามิเตอร์ซึ่งเรียกว่า formal parameters.
• นอกเหนือจากฟังก์ชันทั้งหมดซึ่งเรียกว่า global variables.

ตัวแปรท้องถิ่น

ตัวแปรที่ประกาศภายในฟังก์ชันหรือบล็อกเป็นตัวแปรภายใน สามารถใช้ได้โดยคำสั่งที่อยู่ในฟังก์ชันหรือบล็อกโค้ดนั้นเท่านั้น ไม่ทราบว่าตัวแปรท้องถิ่นทำหน้าที่ภายนอกตัวเอง ต่อไปนี้เป็นตัวอย่างการใช้ตัวแปรท้องถิ่น -

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

ตัวแปรส่วนกลาง

ตัวแปรส่วนกลางถูกกำหนดไว้นอกฟังก์ชันทั้งหมดโดยปกติจะอยู่ที่ด้านบนสุดของโปรแกรม ตัวแปรส่วนกลางจะคงคุณค่าไว้ตลอดอายุของโปรแกรมของคุณ

ฟังก์ชันใด ๆ สามารถเข้าถึงตัวแปรส่วนกลางได้ นั่นคือตัวแปรส่วนกลางพร้อมใช้งานตลอดทั้งโปรแกรมของคุณหลังจากการประกาศ

ตัวอย่างต่อไปนี้ใช้ตัวแปรส่วนกลางและท้องถิ่น -

Int T , S ;
float c = 0 ; Global variable declaration

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

ตัวดำเนินการคือสัญลักษณ์ที่บอกให้คอมไพเลอร์ทำหน้าที่ทางคณิตศาสตร์หรือตรรกะเฉพาะ ภาษา C อุดมไปด้วยตัวดำเนินการในตัวและมีตัวดำเนินการประเภทต่อไปนี้ -

• ตัวดำเนินการเลขคณิต
• ตัวดำเนินการเปรียบเทียบ
• ตัวดำเนินการบูลีน
• ตัวดำเนินการ Bitwise
• ตัวดำเนินการผสม

ตัวดำเนินการเลขคณิต

สมมติว่าตัวแปร A ถือ 10 และตัวแปร B ถือ 20 แล้ว -

แสดงตัวอย่าง

ชื่อผู้ดำเนินการ	ตัวดำเนินการที่เรียบง่าย	คำอธิบาย	ตัวอย่าง
ผู้ดำเนินการมอบหมาย	=	เก็บค่าไว้ทางขวาของเครื่องหมายเท่ากับในตัวแปรทางด้านซ้ายของเครื่องหมายเท่ากับ	ก = ข
ส่วนที่เพิ่มเข้าไป	+	เพิ่มสองตัวถูกดำเนินการ	A + B จะให้ 30
การลบ	-	ลบตัวถูกดำเนินการที่สองจากตัวแรก	A - B จะให้ -10
การคูณ	*	คูณตัวถูกดำเนินการทั้งสอง	A * B จะให้ 200
แผนก	/	หารตัวเศษด้วยตัวส่วน	B / A จะให้ 2
โมดูโล	%	ตัวดำเนินการโมดูลัสและส่วนที่เหลือหลังจากการหารจำนวนเต็ม	B% A จะให้ 0

ตัวดำเนินการเปรียบเทียบ

สมมติว่าตัวแปร A ถือ 10 และตัวแปร B ถือ 20 แล้ว -

แสดงตัวอย่าง

ชื่อผู้ดำเนินการ	ตัวดำเนินการที่เรียบง่าย	คำอธิบาย	ตัวอย่าง
เท่ากับ	==	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A == B) ไม่เป็นความจริง
ไม่เท่ากับ	! =	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง	(A! = B) เป็นจริง
น้อยกว่า	<	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A <B) เป็นจริง
มากกว่า	>	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A> B) ไม่เป็นความจริง
น้อยกว่าหรือเท่ากับ	<=	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A <= B) เป็นจริง
มากกว่าหรือเท่ากับ	> =	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A> = B) ไม่เป็นความจริง

ตัวดำเนินการบูลีน

สมมติว่าตัวแปร A ถือ 10 และตัวแปร B ถือ 20 แล้ว -

แสดงตัวอย่าง

ชื่อผู้ดำเนินการ	ตัวดำเนินการที่เรียบง่าย	คำอธิบาย	ตัวอย่าง
และ	&&	เรียกว่าตัวดำเนินการ Logical AND หากตัวถูกดำเนินการทั้งสองไม่ใช่ศูนย์เงื่อนไขจะกลายเป็นจริง	(A && B) เป็นเรื่องจริง
หรือ	||	เรียกว่า Logical OR Operator ถ้าตัวถูกดำเนินการสองตัวใดตัวหนึ่งไม่เป็นศูนย์เงื่อนไขจะกลายเป็นจริง	(A || B) เป็นจริง
ไม่	!	เรียกว่า Logical NOT Operator ใช้เพื่อย้อนกลับสถานะตรรกะของตัวถูกดำเนินการ หากเงื่อนไขเป็นจริงตัวดำเนินการ Logical NOT จะสร้างเท็จ	! (A && B) เป็นเท็จ

ตัวดำเนินการ Bitwise

สมมติตัวแปร A ถือ 60 และตัวแปร B ถือ 13 แล้ว -

แสดงตัวอย่าง

ชื่อผู้ดำเนินการ	ตัวดำเนินการที่เรียบง่าย	คำอธิบาย	ตัวอย่าง
และ	&	ไบนารี AND Operator จะคัดลอกบิตไปยังผลลัพธ์หากมีอยู่ในตัวถูกดำเนินการทั้งสอง	(A & B) จะให้ 12 ซึ่งเท่ากับ 0000 1100
หรือ	|	ไบนารีหรือตัวดำเนินการจะคัดลอกบิตหากมีอยู่ในตัวถูกดำเนินการอย่างใดอย่างหนึ่ง	(A | B) จะให้ 61 ซึ่งก็คือ 0011 1101
xor	^	ตัวดำเนินการ XOR ไบนารีจะคัดลอกบิตหากตั้งค่าไว้ในตัวถูกดำเนินการเดียว แต่ไม่ใช่ทั้งสองอย่าง	(A ^ B) จะให้ 49 ซึ่งก็คือ 0011 0001
ไม่	~	Binary Ones Complement Operator เป็นเอกภาพและมีผลของบิต 'พลิก'	(~ A) จะให้ -60 ซึ่งก็คือ 1100 0011
เลื่อนไปทางซ้าย	<<	ตัวดำเนินการกะซ้ายแบบไบนารี ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางซ้ายตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา	A << 2 จะให้ 240 ซึ่งก็คือ 1111 0000
เลื่อนไปทางขวา	>>	ตัวดำเนินการกะไบนารีขวา ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางขวาตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา	A >> 2 จะให้ 15 ซึ่งก็คือ 0000 1111

ตัวดำเนินการผสม

สมมติว่าตัวแปร A ถือ 10 และตัวแปร B ถือ 20 แล้ว -

แสดงตัวอย่าง

ชื่อผู้ดำเนินการ	ตัวดำเนินการที่เรียบง่าย	คำอธิบาย	ตัวอย่าง
เพิ่มขึ้น	++	ตัวดำเนินการที่เพิ่มขึ้นเพิ่มค่าจำนวนเต็มทีละตัว	A ++ จะให้ 11
ลดลง	-	ตัวดำเนินการลดลงลดค่าจำนวนเต็มทีละหนึ่ง	A-- จะให้ 9
นอกจากนี้สารประกอบ	+ =	เพิ่มและกำหนดตัวดำเนินการ เพิ่มตัวถูกดำเนินการด้านขวาให้กับตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย	B + = A เทียบเท่ากับ B = B + A
การลบสารประกอบ	- =	ตัวดำเนินการลบและกำหนด มันจะลบตัวถูกดำเนินการด้านขวาออกจากตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย	B - = A เทียบเท่ากับ B = B - A
การคูณสารประกอบ	* =	ตัวดำเนินการคูณและกำหนด จะคูณตัวถูกดำเนินการด้านขวากับตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย	B * = A เทียบเท่ากับ B = B * A
การแบ่งสารประกอบ	/ =	หารและกำหนดตัวดำเนินการ มันแบ่งตัวถูกดำเนินการด้านซ้ายกับตัวถูกดำเนินการด้านขวาและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย	B / = A เทียบเท่ากับ B = B / A
โมดูโลสารประกอบ	% =	โมดูลัสและตัวดำเนินการกำหนด ใช้โมดูลัสโดยใช้ตัวถูกดำเนินการสองตัวและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย	B% = A เทียบเท่ากับ B = B% A
ผสมบิตหรือ	| =	รวมบิตหรือและตัวดำเนินการกำหนด	A | = 2 เหมือนกับ A = A | 2
สารประกอบในระดับบิตและ	& =	ตัวดำเนินการกำหนด Bitwise AND	A & = 2 เหมือนกับ A = A & 2

โครงสร้างการตัดสินใจกำหนดให้โปรแกรมเมอร์ระบุเงื่อนไขอย่างน้อยหนึ่งเงื่อนไขที่จะประเมินหรือทดสอบโดยโปรแกรม ควรใช้ร่วมกับคำสั่งหรือคำสั่งที่จะดำเนินการหากเงื่อนไขถูกกำหนดให้เป็นจริงและเป็นทางเลือกที่จะเรียกใช้คำสั่งอื่นหากเงื่อนไขถูกกำหนดให้เป็นเท็จ

ต่อไปนี้เป็นรูปแบบทั่วไปของโครงสร้างการตัดสินใจทั่วไปที่พบในภาษาโปรแกรมส่วนใหญ่ -

คำสั่งควบคุมเป็นองค์ประกอบในซอร์สโค้ดที่ควบคุมขั้นตอนการทำงานของโปรแกรม พวกเขาคือ -

ส. อบจ.	คำชี้แจงและคำอธิบายการควบคุม
1	ถ้าคำสั่ง ใช้นิพจน์ในวงเล็บและคำสั่งหรือบล็อกของคำสั่ง หากนิพจน์เป็นจริงคำสั่งหรือบล็อกของคำสั่งจะถูกดำเนินการมิฉะนั้นคำสั่งเหล่านี้จะถูกข้ามไป
2	ถ้า…คำสั่งอื่น อัน if สามารถตามด้วยคำสั่งอื่นที่เป็นทางเลือกซึ่งจะดำเนินการเมื่อนิพจน์เป็นเท็จ
3	ถ้า… else if … else คำสั่ง if ตามด้วยคำสั่งก็ได้ else if...else ซึ่งมีประโยชน์มากในการทดสอบเงื่อนไขต่างๆโดยใช้คำสั่ง single if ... else if
4	สลับคำสั่งกรณี คล้ายกับคำสั่ง if switch...case ควบคุมการไหลของโปรแกรมโดยอนุญาตให้โปรแกรมเมอร์ระบุรหัสต่างๆที่ควรดำเนินการในเงื่อนไขต่างๆ
5	ตัวดำเนินการตามเงื่อนไข? : ตัวดำเนินการตามเงื่อนไข? : เป็นตัวดำเนินการ ternary เพียงตัวเดียวใน C.

ภาษาโปรแกรมจัดเตรียมโครงสร้างการควบคุมต่างๆที่ช่วยให้เส้นทางการดำเนินการซับซ้อนมากขึ้น

คำสั่งวนซ้ำช่วยให้เราดำเนินการคำสั่งหรือกลุ่มของคำสั่งได้หลายครั้งและต่อไปนี้เป็นรูปแบบทั่วไปของคำสั่งลูปในภาษาโปรแกรมส่วนใหญ่ -

การเขียนโปรแกรมภาษาซีจัดเตรียมลูปประเภทต่อไปนี้เพื่อจัดการกับข้อกำหนดการวนซ้ำ

ส. อบจ.	ห่วงและคำอธิบาย
1	ในขณะที่วนซ้ำ ในขณะที่ลูปจะวนซ้ำอย่างต่อเนื่องและไม่มีที่สิ้นสุดจนกว่านิพจน์ภายในวงเล็บ () จะกลายเป็นเท็จ ต้องมีบางอย่างเปลี่ยนตัวแปรที่ทดสอบไม่เช่นนั้นลูป while จะไม่ออก
2	ทำ…ในขณะที่วนซ้ำ do…whileloop คล้ายกับ while loop ใน while ลูปเงื่อนไขการต่อเนื่องของลูปจะถูกทดสอบที่จุดเริ่มต้นของลูปก่อนที่จะดำเนินการร่างของลูป
3	สำหรับห่วง ก for loopดำเนินการคำสั่งตามจำนวนครั้งที่กำหนดไว้ล่วงหน้า นิพจน์ควบคุมสำหรับลูปถูกเตรียมใช้งานทดสอบและจัดการทั้งหมดภายในวงเล็บสำหรับลูป
4	ห่วงที่ซ้อนกัน ภาษา C ช่วยให้คุณใช้ลูปหนึ่งในอีกลูปได้ ตัวอย่างต่อไปนี้แสดงให้เห็นถึงแนวคิด
5	วนไม่มีสิ้นสุด มันเป็นลูปที่ไม่มีเงื่อนไขสิ้นสุดดังนั้นลูปจึงไม่มีที่สิ้นสุด

ฟังก์ชั่นช่วยให้สามารถจัดโครงสร้างโปรแกรมในส่วนของโค้ดเพื่อดำเนินการแต่ละงาน กรณีทั่วไปในการสร้างฟังก์ชันคือเมื่อต้องดำเนินการเดียวกันหลาย ๆ ครั้งในโปรแกรม

การกำหนดมาตรฐานชิ้นส่วนโค้ดให้เป็นฟังก์ชันมีข้อดีหลายประการ -

• ฟังก์ชันช่วยให้โปรแกรมเมอร์เป็นระเบียบ บ่อยครั้งสิ่งนี้ช่วยในการกำหนดแนวคิดของโปรแกรม

• ฟังก์ชั่นประมวลผลหนึ่งการกระทำในที่เดียวดังนั้นฟังก์ชันจะต้องได้รับการพิจารณาและแก้ไขข้อบกพร่องเพียงครั้งเดียว

• นอกจากนี้ยังช่วยลดโอกาสในการแก้ไขข้อผิดพลาดหากจำเป็นต้องเปลี่ยนรหัส

• ฟังก์ชั่นทำให้ร่างทั้งหมดเล็กลงและกะทัดรัดยิ่งขึ้นเนื่องจากส่วนของโค้ดถูกนำมาใช้ซ้ำหลายครั้ง

• ทำให้ง่ายต่อการนำโค้ดมาใช้ซ้ำในโปรแกรมอื่น ๆ โดยทำให้เป็นแบบแยกส่วนและการใช้ฟังก์ชันมักจะทำให้โค้ดอ่านง่ายขึ้น

มีสองฟังก์ชันที่จำเป็นในร่าง Arduino หรือโปรแกรมเช่นการตั้งค่า () และลูป () ต้องสร้างฟังก์ชันอื่น ๆ นอกวงเล็บของฟังก์ชันทั้งสองนี้

ไวยากรณ์ที่ใช้บ่อยที่สุดในการกำหนดฟังก์ชันคือ -

การประกาศฟังก์ชัน

มีการประกาศฟังก์ชันภายนอกฟังก์ชันอื่นใดด้านบนหรือด้านล่างของฟังก์ชันลูป

เราสามารถประกาศฟังก์ชันได้สองวิธี -

วิธีแรกเพียงแค่เขียนส่วนของฟังก์ชันที่เรียกว่า a function prototype เหนือฟังก์ชันลูปซึ่งประกอบด้วย -

• ประเภทการส่งคืนฟังก์ชัน
• ชื่อฟังก์ชัน
• ประเภทอาร์กิวเมนต์ของฟังก์ชันไม่จำเป็นต้องเขียนชื่ออาร์กิวเมนต์

ต้นแบบฟังก์ชันต้องตามด้วยอัฒภาค (;)

ตัวอย่างต่อไปนี้แสดงการสาธิตการประกาศฟังก์ชันโดยใช้วิธีแรก

ตัวอย่าง

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

ส่วนที่สองซึ่งเรียกว่าการกำหนดฟังก์ชันหรือการประกาศจะต้องถูกประกาศไว้ด้านล่างของฟังก์ชันลูปซึ่งประกอบด้วย -

• ประเภทการส่งคืนฟังก์ชัน
• ชื่อฟังก์ชัน
• ประเภทอาร์กิวเมนต์ของฟังก์ชันคุณต้องเพิ่มชื่ออาร์กิวเมนต์ที่นี่
• เนื้อความของฟังก์ชัน (คำสั่งภายในฟังก์ชันที่ดำเนินการเมื่อฟังก์ชันถูกเรียกใช้)

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการประกาศฟังก์ชันโดยใช้วิธีที่สอง

ตัวอย่าง

int sum_func (int , int ) ; // function prototype

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

วิธีที่สองเพียงแค่ประกาศฟังก์ชันเหนือฟังก์ชันลูป

สตริงใช้ในการจัดเก็บข้อความ สามารถใช้เพื่อแสดงข้อความบน LCD หรือในหน้าต่าง Arduino IDE Serial Monitor สตริงยังมีประโยชน์สำหรับการจัดเก็บอินพุตของผู้ใช้ ตัวอย่างเช่นอักขระที่ผู้ใช้พิมพ์บนแป้นพิมพ์ที่เชื่อมต่อกับ Arduino

มีสองประเภทของสตริงในการเขียนโปรแกรม Arduino -

• อาร์เรย์ของอักขระซึ่งเหมือนกับสตริงที่ใช้ในการเขียนโปรแกรม C
• Arduino String ซึ่งให้เราใช้วัตถุสตริงในภาพร่าง

ในบทนี้เราจะเรียนรู้ Strings วัตถุและการใช้สตริงในภาพร่าง Arduino ในตอนท้ายของบทคุณจะได้เรียนรู้ประเภทของสตริงที่จะใช้ในภาพร่าง

อาร์เรย์อักขระสตริง

สตริงประเภทแรกที่เราจะเรียนรู้คือสตริงที่เป็นชุดของอักขระประเภท char. ในบทที่แล้วเราได้เรียนรู้ว่าอาร์เรย์คืออะไร ชุดตัวแปรประเภทเดียวกันที่เก็บไว้ในหน่วยความจำ สตริงคืออาร์เรย์ของตัวแปรถ่าน

สตริงคืออาร์เรย์พิเศษที่มีองค์ประกอบพิเศษหนึ่งรายการที่ส่วนท้ายของสตริงซึ่งจะมีค่าเป็น 0 (ศูนย์) เสมอ ซึ่งเรียกว่า "สตริงที่สิ้นสุดด้วยค่าว่าง"

ตัวอย่างอาร์เรย์อักขระสตริง

ตัวอย่างนี้จะแสดงวิธีการสร้างสตริงและพิมพ์ไปยังหน้าต่างมอนิเตอร์แบบอนุกรม

Example

void setup() {
   char my_str[6]; // an array big enough for a 5 character string
   Serial.begin(9600);
   my_str[0] = 'H'; // the string consists of 5 characters
   my_str[1] = 'e';
   my_str[2] = 'l';
   my_str[3] = 'l';
   my_str[4] = 'o';
   my_str[5] = 0; // 6th array element is a null terminator
   Serial.println(my_str);
}

void loop() { 

}

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสตริงประกอบด้วยอะไร อาร์เรย์อักขระที่มีอักขระที่พิมพ์ได้และ 0 เป็นองค์ประกอบสุดท้ายของอาร์เรย์เพื่อแสดงว่านี่คือจุดที่สตริงสิ้นสุด สามารถพิมพ์สตริงออกไปยังหน้าต่าง Arduino IDE Serial Monitor ได้โดยใช้Serial.println() และส่งชื่อของสตริง

ตัวอย่างเดียวกันนี้สามารถเขียนด้วยวิธีที่สะดวกกว่าดังแสดงด้านล่าง -

Example

void setup() {
   char my_str[] = "Hello";
   Serial.begin(9600);
   Serial.println(my_str);
}

void loop() {

}

ในร่างนี้คอมไพลเลอร์จะคำนวณขนาดของสตริงอาร์เรย์และ null โดยอัตโนมัติจะสิ้นสุดสตริงด้วยศูนย์ อาร์เรย์ที่มีความยาวหกองค์ประกอบและประกอบด้วยอักขระห้าตัวตามด้วยศูนย์จะถูกสร้างขึ้นในลักษณะเดียวกับในร่างก่อนหน้า

การจัดการสตริงอาร์เรย์

เราสามารถเปลี่ยนสตริงอาร์เรย์ภายในร่างดังที่แสดงในร่างต่อไปนี้

ตัวอย่าง

void setup() {
   char like[] = "I like coffee and cake"; // create a string
   Serial.begin(9600);
   // (1) print the string
   Serial.println(like);
   // (2) delete part of the string
   like[13] = 0;
   Serial.println(like);
   // (3) substitute a word into the string
   like[13] = ' '; // replace the null terminator with a space
   like[18] = 't'; // insert the new word
   like[19] = 'e';
   like[20] = 'a';
   like[21] = 0; // terminate the string
   Serial.println(like);
}

void loop() {

}

ผลลัพธ์

I like coffee and cake
I like coffee
I like coffee and tea

ภาพร่างทำงานในลักษณะต่อไปนี้

การสร้างและพิมพ์สตริง

ในภาพร่างที่ระบุข้างต้นสตริงใหม่จะถูกสร้างขึ้นจากนั้นพิมพ์เพื่อแสดงในหน้าต่าง Serial Monitor

การย่อสตริง

สตริงถูกทำให้สั้นลงโดยการแทนที่อักขระที่ 14 ในสตริงด้วยค่าว่างที่สิ้นสุดศูนย์ (2) นี่คือองค์ประกอบหมายเลข 13 ในอาร์เรย์สตริงนับจาก 0

เมื่อสตริงถูกพิมพ์อักขระทั้งหมดจะถูกพิมพ์จนถึงค่าว่างใหม่ที่สิ้นสุดศูนย์ อักขระอื่น ๆ ไม่หายไป; ยังคงมีอยู่ในหน่วยความจำและสตริงอาร์เรย์ยังคงมีขนาดเท่าเดิม ข้อแตกต่างเพียงอย่างเดียวคือฟังก์ชันใด ๆ ที่ทำงานกับสตริงจะเห็นเฉพาะสตริงที่มีค่าสูงสุดเป็นตัวกำหนดค่าว่างตัวแรก

การเปลี่ยนคำในสตริง

ในที่สุดภาพร่างจะแทนที่คำว่า "เค้ก" ด้วย "ชา" (3) ก่อนอื่นจะต้องแทนที่เทอร์มิเนเตอร์ null ที่ like [13] ด้วยช่องว่างเพื่อให้สตริงคืนค่าเป็นรูปแบบที่สร้างขึ้นครั้งแรก

อักขระใหม่เขียนทับ "cak" ของคำว่า "เค้ก" ด้วยคำว่า "tea" ซึ่งทำได้โดยการเขียนทับอักขระแต่ละตัว "e" ของ "เค้ก" จะถูกแทนที่ด้วยอักขระยุติโมฆะใหม่ ผลลัพธ์ก็คือสตริงถูกยกเลิกด้วยอักขระว่างสองตัวโดยตัวเดิมอยู่ท้ายสตริงและสตริงใหม่ที่แทนที่ "e" ใน "เค้ก" สิ่งนี้ไม่สร้างความแตกต่างเมื่อพิมพ์สตริงใหม่เนื่องจากฟังก์ชันที่พิมพ์สตริงจะหยุดพิมพ์อักขระสตริงเมื่อพบกับตัวยุติค่าว่างตัวแรก

ฟังก์ชั่นในการจัดการอาร์เรย์สตริง

ภาพร่างก่อนหน้านี้จัดการสตริงด้วยตนเองโดยการเข้าถึงอักขระแต่ละตัวในสตริง เพื่อให้ง่ายต่อการจัดการอาร์เรย์สตริงคุณสามารถเขียนฟังก์ชันของคุณเองเพื่อทำเช่นนั้นหรือใช้ฟังก์ชันสตริงจากC ห้องสมุดภาษา

ด้านล่างคือรายการฟังก์ชั่นในการจัดการสตริงอาร์เรย์

ส.	ฟังก์ชั่นและคำอธิบาย
1	String() คลาส String ซึ่งเป็นส่วนหนึ่งของคอร์ในเวอร์ชัน 0019 ช่วยให้คุณสามารถใช้และจัดการสตริงของข้อความในรูปแบบที่ซับซ้อนกว่าอาร์เรย์อักขระ คุณสามารถต่อสตริงต่อท้ายค้นหาและแทนที่สตริงย่อยและอื่น ๆ ใช้หน่วยความจำมากกว่าอาร์เรย์อักขระธรรมดา แต่ก็มีประโยชน์มากกว่าเช่นกัน สำหรับการอ้างอิงอาร์เรย์อักขระจะเรียกว่าสตริงที่มี 's' ขนาดเล็กและอินสแตนซ์ของคลาสสตริงจะเรียกว่าสตริงที่มีตัวพิมพ์ใหญ่ S โปรดทราบว่าสตริงคงที่ซึ่งระบุใน "เครื่องหมายคำพูดคู่" จะถือว่าเป็นอาร์เรย์ถ่าน ไม่ใช่อินสแตนซ์ของคลาส String
2	charAt() เข้าถึงอักขระเฉพาะของ String
3	compareTo() เปรียบเทียบสตริงสองสายทดสอบว่าสตริงหนึ่งมาก่อนหรือหลังอีกสตริงหรือว่ามีค่าเท่ากัน สตริงถูกเปรียบเทียบอักขระตามอักขระโดยใช้ค่า ASCII ของอักขระ นั่นหมายความว่าตัวอย่างเช่น "a" มาก่อน "b" แต่อยู่หลัง "A" ตัวเลขมาก่อนตัวอักษร
4	concat() ผนวกพารามิเตอร์เข้ากับสตริง
5	c_str() แปลงเนื้อหาของสตริงเป็นสตริงสไตล์ C ที่สิ้นสุดด้วยค่า null โปรดทราบว่าสิ่งนี้ให้การเข้าถึงโดยตรงไปยังบัฟเฟอร์สตริงภายในและควรใช้ด้วยความระมัดระวัง โดยเฉพาะอย่างยิ่งคุณไม่ควรแก้ไขสตริงผ่านตัวชี้ที่ส่งกลับ เมื่อคุณแก้ไขออบเจ็กต์ String หรือเมื่อถูกทำลายตัวชี้ใด ๆ ที่ส่งกลับมาก่อนหน้านี้โดย c_str () จะไม่ถูกต้องและไม่ควรใช้อีกต่อไป
6	endsWith() ทดสอบว่า String ลงท้ายด้วยอักขระของ String อื่นหรือไม่
7	equals() เปรียบเทียบสองสตริงเพื่อความเท่าเทียมกัน การเปรียบเทียบจะคำนึงถึงตัวพิมพ์เล็กและใหญ่ซึ่งหมายความว่า String "hello" ไม่เท่ากับ String "HELLO"
8	equalsIgnoreCase() เปรียบเทียบสองสตริงเพื่อความเท่าเทียมกัน การเปรียบเทียบไม่คำนึงถึงขนาดตัวพิมพ์ซึ่งหมายความว่า String ("hello") เท่ากับ String ("HELLO")
9	getBytes() คัดลอกอักขระของสตริงไปยังบัฟเฟอร์ที่ให้มา
10	indexOf() ค้นหาอักขระหรือสตริงภายในสตริงอื่น โดยค่าเริ่มต้นจะค้นหาจากจุดเริ่มต้นของ String แต่ยังสามารถเริ่มต้นจากดัชนีที่กำหนดเพื่อให้สามารถค้นหาอินสแตนซ์ทั้งหมดของอักขระหรือ String ได้
11	lastIndexOf() ค้นหาอักขระหรือสตริงภายในสตริงอื่น โดยค่าเริ่มต้นจะค้นหาจากส่วนท้ายของ String แต่ยังสามารถทำงานย้อนกลับจากดัชนีที่กำหนดเพื่อให้สามารถค้นหาอินสแตนซ์ทั้งหมดของอักขระหรือ String ได้
12	length() ส่งกลับความยาวของ String เป็นอักขระ (โปรดทราบว่าสิ่งนี้ไม่รวมอักขระ null ต่อท้าย)
13	remove() แก้ไขในสถานที่สตริงที่ลบตัวอักษรออกจากดัชนีที่ให้ไปยังจุดสิ้นสุดของสตริงหรือจากดัชนีที่ให้มาเพื่อนับดัชนีบวก
14	replace() ฟังก์ชัน String replace () ช่วยให้คุณสามารถแทนที่อินสแตนซ์ทั้งหมดของอักขระที่กำหนดด้วยอักขระอื่น คุณยังสามารถใช้การแทนที่เพื่อแทนที่สตริงย่อยของสตริงด้วยสตริงย่อยอื่น
15	reserve() ฟังก์ชัน String reserve () ช่วยให้คุณสามารถจัดสรรบัฟเฟอร์ในหน่วยความจำสำหรับจัดการสตริง
16	setCharAt() ตั้งค่าอักขระของ String ไม่มีผลกับดัชนีที่อยู่นอกความยาวที่มีอยู่ของ String
17	startsWith() ทดสอบว่า String เริ่มต้นด้วยอักขระของ String อื่นหรือไม่
18	toCharArray() คัดลอกอักขระของสตริงไปยังบัฟเฟอร์ที่ให้มา
19	substring() รับสตริงย่อยของสตริง ดัชนีเริ่มต้นรวมอยู่ด้วย (อักขระที่เกี่ยวข้องจะรวมอยู่ในสตริงย่อย) แต่ดัชนีสิ้นสุดที่เป็นทางเลือกเป็นเอกสิทธิ์ (ไม่รวมอักขระที่เกี่ยวข้องในสตริงย่อย) หากไม่ใส่ดัชนีสิ้นสุดสตริงย่อยจะต่อไปที่จุดสิ้นสุดของสตริง
20	toInt() แปลงสตริงที่ถูกต้องเป็นจำนวนเต็ม สตริงอินพุตควรเริ่มต้นด้วยตัวเลขจำนวนเต็ม หากสตริงมีตัวเลขที่ไม่ใช่จำนวนเต็มฟังก์ชันจะหยุดดำเนินการแปลง
21	toFloat() แปลงสตริงที่ถูกต้องเป็น float สตริงอินพุตควรเริ่มต้นด้วยตัวเลข หากสตริงมีอักขระที่ไม่ใช่ตัวเลขฟังก์ชันจะหยุดดำเนินการแปลง ตัวอย่างเช่นสตริง "123.45" "123" และ "123fish" จะถูกแปลงเป็น 123.45, 123.00 และ 123.00 ตามลำดับ โปรดทราบว่า "123.456" มีค่าประมาณ 123.46 โปรดทราบด้วยว่าการลอยตัวมีความแม่นยำเพียง 6-7 หลักและสตริงที่ยาวกว่านั้นอาจถูกตัดทอน
22	toLowerCase() รับ String เวอร์ชันตัวพิมพ์เล็ก ณ วันที่ 1.0 toLowerCase () แก้ไขสตริงแทนการส่งคืนใหม่
23	toUpperCase() รับ String เวอร์ชันตัวพิมพ์ใหญ่ ณ วันที่ 1.0 toUpperCase () จะแก้ไขสตริงแทนการส่งคืนสตริงใหม่
24	trim() รับเวอร์ชันของ String โดยลบช่องว่างที่นำหน้าและต่อท้ายออก ณ วันที่ 1.0 trim () จะแก้ไขสตริงแทนการส่งคืนสตริงใหม่

ร่างถัดไปใช้ฟังก์ชันสตริง C

ตัวอย่าง

void setup() {
   char str[] = "This is my string"; // create a string
   char out_str[40]; // output from string functions placed here
   int num; // general purpose integer
   Serial.begin(9600);

   // (1) print the string
   Serial.println(str);

   // (2) get the length of the string (excludes null terminator)
   num = strlen(str);
   Serial.print("String length is: ");
   Serial.println(num);

   // (3) get the length of the array (includes null terminator)
   num = sizeof(str); // sizeof() is not a C string function
   Serial.print("Size of the array: ");
   Serial.println(num);

   // (4) copy a string
   strcpy(out_str, str);
   Serial.println(out_str);

   // (5) add a string to the end of a string (append)
   strcat(out_str, " sketch.");
   Serial.println(out_str);
   num = strlen(out_str);
   Serial.print("String length is: ");
   Serial.println(num);
   num = sizeof(out_str);
   Serial.print("Size of the array out_str[]: ");
   Serial.println(num);
}

void loop() {

}

ผลลัพธ์

This is my string
String length is: 17
Size of the array: 18
This is my string
This is my string sketch.
String length is: 25
Size of the array out_str[]: 40

ภาพร่างทำงานในลักษณะต่อไปนี้

พิมพ์สตริง

สตริงที่สร้างขึ้นใหม่จะพิมพ์ไปยังหน้าต่าง Serial Monitor ตามที่ทำในภาพร่างก่อนหน้านี้

รับความยาวของสตริง

ฟังก์ชัน strlen () ใช้เพื่อรับความยาวของสตริง ความยาวของสตริงมีไว้สำหรับอักขระที่พิมพ์ได้เท่านั้นและไม่รวมเทอร์มิเนเตอร์ว่าง

สตริงประกอบด้วยอักขระ 17 ตัวดังนั้นเราจึงเห็น 17 พิมพ์ในหน้าต่าง Serial Monitor

รับความยาวของอาร์เรย์

ตัวดำเนินการ sizeof () ใช้เพื่อรับความยาวของอาร์เรย์ที่มีสตริง ความยาวมีตัวบอกเลิกโมฆะดังนั้นความยาวจึงมากกว่าความยาวของสตริง

sizeof () ดูเหมือนฟังก์ชัน แต่ในทางเทคนิคแล้วเป็นตัวดำเนินการ ไม่ได้เป็นส่วนหนึ่งของไลบรารีสตริง C แต่ถูกใช้ในแบบร่างเพื่อแสดงความแตกต่างระหว่างขนาดของอาร์เรย์และขนาดของสตริง (หรือความยาวสตริง)

คัดลอกสตริง

ฟังก์ชัน strcpy () ใช้เพื่อคัดลอกสตริง str [] ไปยังอาร์เรย์ out_num [] ฟังก์ชัน strcpy () คัดลอกสตริงที่สองที่ส่งผ่านไปยังสตริงแรก ขณะนี้สำเนาของสตริงมีอยู่ในอาร์เรย์ out_num [] แต่ใช้เพียง 18 องค์ประกอบของอาร์เรย์ดังนั้นเราจึงยังมีองค์ประกอบถ่าน 22 องค์ประกอบฟรีในอาร์เรย์ องค์ประกอบฟรีเหล่านี้พบได้หลังสตริงในหน่วยความจำ

สตริงถูกคัดลอกไปยังอาร์เรย์เพื่อให้เรามีพื้นที่พิเศษในอาร์เรย์เพื่อใช้ในส่วนถัดไปของร่างซึ่งเป็นการเพิ่มสตริงที่ส่วนท้ายของสตริง

ต่อท้ายสตริงกับสตริง (เชื่อมต่อกัน)

ร่างรวมสตริงหนึ่งเข้ากับอีกสตริงหนึ่งซึ่งเรียกว่าการเรียงต่อกัน ทำได้โดยใช้ฟังก์ชัน strcat () ฟังก์ชัน strcat () ทำให้สตริงที่สองส่งผ่านไปยังจุดสิ้นสุดของสตริงแรกที่ส่งผ่านไป

หลังจากการเชื่อมต่อกันความยาวของสตริงจะถูกพิมพ์เพื่อแสดงความยาวสตริงใหม่ จากนั้นจะพิมพ์ความยาวของอาร์เรย์เพื่อแสดงว่าเรามีสตริงยาว 25 อักขระในอาร์เรย์แบบยาว 40 องค์ประกอบ

โปรดจำไว้ว่าสตริงยาว 25 อักขระใช้อักขระ 26 ตัวของอาร์เรย์เนื่องจากค่าว่างสิ้นสุดศูนย์

ขอบเขตอาร์เรย์

เมื่อทำงานกับสตริงและอาร์เรย์สิ่งสำคัญมากที่จะต้องทำงานภายในขอบเขตของสตริงหรืออาร์เรย์ ในภาพร่างตัวอย่างอาร์เรย์ถูกสร้างขึ้นซึ่งมีความยาว 40 อักขระเพื่อจัดสรรหน่วยความจำที่สามารถใช้จัดการกับสตริงได้

ถ้าอาร์เรย์มีขนาดเล็กเกินไปและเราพยายามคัดลอกสตริงที่ใหญ่กว่าอาร์เรย์ไปยังอาร์เรย์สตริงจะถูกคัดลอกไปที่ส่วนท้ายของอาร์เรย์ หน่วยความจำที่อยู่เกินส่วนท้ายของอาร์เรย์อาจมีข้อมูลสำคัญอื่น ๆ ที่ใช้ในภาพร่างซึ่งจะถูกเขียนทับโดยสตริงของเรา หากหน่วยความจำที่อยู่เกินส่วนท้ายของสตริงถูกใช้งานมากเกินไปอาจทำให้ภาพร่างเสียหายหรือทำให้เกิดพฤติกรรมที่ไม่คาดคิด

สตริงประเภทที่สองที่ใช้ในการเขียนโปรแกรม Arduino คือ String Object

วัตถุคืออะไร?

ออบเจ็กต์คือโครงสร้างที่มีทั้งข้อมูลและฟังก์ชัน ออบเจ็กต์ String สามารถสร้างได้เช่นเดียวกับตัวแปรและกำหนดค่าหรือสตริง วัตถุ String ประกอบด้วยฟังก์ชัน (ซึ่งเรียกว่า "วิธีการ" ในการเขียนโปรแกรมเชิงวัตถุ (OOP)) ซึ่งดำเนินการกับข้อมูลสตริงที่มีอยู่ในวัตถุ String

ภาพร่างและคำอธิบายต่อไปนี้จะทำให้ชัดเจนว่าวัตถุคืออะไรและใช้วัตถุ String อย่างไร

ตัวอย่าง

void setup() { 
   String my_str = "This is my string.";
   Serial.begin(9600);

   // (1) print the string
   Serial.println(my_str);

   // (2) change the string to upper-case
   my_str.toUpperCase();
   Serial.println(my_str);

   // (3) overwrite the string
   my_str = "My new string.";
   Serial.println(my_str);

   // (4) replace a word in the string
   my_str.replace("string", "Arduino sketch");
   Serial.println(my_str);

   // (5) get the length of the string
   Serial.print("String length is: ");
   Serial.println(my_str.length());
}

void loop() { 

}

ผลลัพธ์

This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
String length is: 22

อ็อบเจ็กต์สตริงถูกสร้างและกำหนดค่า (หรือสตริง) ที่ด้านบนของร่าง

String my_str = "This is my string." ;

สิ่งนี้สร้างวัตถุสตริงที่มีชื่อ my_str และให้ค่าเป็น "นี่คือสตริงของฉัน"

สิ่งนี้สามารถเปรียบเทียบได้กับการสร้างตัวแปรและกำหนดค่าให้กับตัวแปรเช่นจำนวนเต็ม -

int my_var = 102;

ภาพร่างทำงานในลักษณะต่อไปนี้

การพิมพ์สตริง

สามารถพิมพ์สตริงไปยังหน้าต่าง Serial Monitor ได้เช่นเดียวกับสตริงอาร์เรย์อักขระ

แปลง String เป็น Upper-case

my_str อ็อบเจ็กต์สตริงที่สร้างขึ้นมีฟังก์ชันหรือวิธีการหลายอย่างที่สามารถดำเนินการได้ วิธีการเหล่านี้เรียกใช้โดยใช้ชื่อวัตถุตามด้วยตัวดำเนินการจุด (.) จากนั้นชื่อของฟังก์ชันที่จะใช้

my_str.toUpperCase();

toUpperCase() ฟังก์ชันทำงานกับสตริงที่มีอยู่ในไฟล์ my_strซึ่งเป็นประเภท String และแปลงข้อมูลสตริง (หรือข้อความ) ที่วัตถุมีเป็นอักขระตัวพิมพ์ใหญ่ รายการฟังก์ชันที่คลาส String มีอยู่ในการอ้างอิง Arduino String ในทางเทคนิค String เรียกว่าคลาสและใช้ในการสร้างวัตถุ String

เขียนทับสตริง

ตัวดำเนินการกำหนดใช้เพื่อกำหนดสตริงใหม่ให้กับ my_str วัตถุที่แทนที่สตริงเก่า

my_str = "My new string." ;

ไม่สามารถใช้ตัวดำเนินการกำหนดกับสตริงอาร์เรย์อักขระ แต่ใช้ได้กับอ็อบเจ็กต์ String เท่านั้น

การแทนที่ Word ใน String

ฟังก์ชัน replace () ใช้เพื่อแทนที่สตริงแรกที่ส่งผ่านไปโดยสตริงที่สองที่ส่งผ่านไป แทนที่ () เป็นฟังก์ชันอื่นที่สร้างขึ้นในคลาส String ดังนั้นจึงพร้อมใช้งานบนอ็อบเจ็กต์ String my_str

รับความยาวของสตริง

การรับความยาวของสตริงทำได้อย่างง่ายดายโดยใช้ length () ในภาพร่างตัวอย่างผลลัพธ์ที่ส่งคืนโดย length () จะถูกส่งไปยัง Serial.println () โดยตรงโดยไม่ต้องใช้ตัวแปรกลาง

เมื่อใดควรใช้ String Object

อ็อบเจ็กต์ String ใช้งานง่ายกว่าอาร์เรย์อักขระสตริง อ็อบเจ็กต์มีฟังก์ชันในตัวที่สามารถดำเนินการกับสตริงได้หลายอย่าง

ข้อเสียเปรียบหลักของการใช้ String object คือใช้หน่วยความจำจำนวนมากและสามารถใช้หน่วยความจำ Arduinos RAM ได้อย่างรวดเร็วซึ่งอาจทำให้ Arduino ค้างขัดข้องหรือทำงานโดยไม่คาดคิด หากภาพร่างบน Arduino มีขนาดเล็กและ จำกัด การใช้วัตถุก็ไม่น่ามีปัญหา

สตริงอาร์เรย์อักขระใช้งานยากกว่าและคุณอาจต้องเขียนฟังก์ชันของคุณเองเพื่อดำเนินการกับสตริงประเภทนี้ ข้อดีคือคุณสามารถควบคุมขนาดของสตริงอาร์เรย์ที่คุณสร้างขึ้นได้ดังนั้นคุณสามารถทำให้อาร์เรย์มีขนาดเล็กเพื่อประหยัดหน่วยความจำ

คุณต้องแน่ใจว่าคุณไม่ได้เขียนเกินขอบเขตอาร์เรย์ด้วยสตริงอาร์เรย์ อ็อบเจ็กต์ String ไม่มีปัญหานี้และจะดูแลขอบเขตสตริงให้คุณหากมีหน่วยความจำเพียงพอที่จะใช้งานได้ อ็อบเจ็กต์ String สามารถพยายามเขียนไปยังหน่วยความจำที่ไม่มีอยู่เมื่อหน่วยความจำหมด แต่จะไม่เขียนต่อท้ายสตริงที่ทำงานอยู่

สถานที่ใช้สตริง

ในบทนี้เราได้ศึกษาเกี่ยวกับสตริงลักษณะการทำงานในหน่วยความจำและการทำงานของพวกเขา

การใช้สตริงในทางปฏิบัติจะกล่าวถึงในส่วนถัดไปของหลักสูตรนี้เมื่อเราศึกษาวิธีรับอินพุตของผู้ใช้จากหน้าต่าง Serial Monitor และบันทึกอินพุตเป็นสตริง

Arduino มีฟังก์ชันการจัดการเวลาที่แตกต่างกันสี่แบบ พวกเขาคือ -

ส.	ฟังก์ชั่นและคำอธิบาย
1	ฟังก์ชัน delay () ทาง delay()ฟังก์ชันการทำงานค่อนข้างเรียบง่าย ยอมรับอาร์กิวเมนต์จำนวนเต็ม (หรือตัวเลข) เดียว ตัวเลขนี้แทนเวลา (วัดเป็นมิลลิวินาที)
2	delayMicroseconds () ฟังก์ชัน delayMicroseconds()ฟังก์ชันยอมรับอาร์กิวเมนต์จำนวนเต็ม (หรือตัวเลข) เดียว มีหนึ่งพันไมโครวินาทีในหนึ่งมิลลิวินาทีและหนึ่งล้านไมโครวินาทีในหนึ่งวินาที
3	มิลลิวินาที () ฟังก์ชัน ฟังก์ชันนี้ใช้เพื่อส่งกลับจำนวนมิลลิวินาทีในเวลานั้นบอร์ด Arduino จะเริ่มรันโปรแกรมปัจจุบัน
4	ไมโคร () ฟังก์ชัน ฟังก์ชัน micros () จะส่งคืนจำนวนไมโครวินาทีจากเวลานั้นบอร์ด Arduino จะเริ่มรันโปรแกรมปัจจุบัน จำนวนนี้ล้นเช่นกลับไปที่ศูนย์หลังจากผ่านไปประมาณ 70 นาที

อาร์เรย์คือกลุ่มของตำแหน่งหน่วยความจำที่ต่อเนื่องกันซึ่งเป็นประเภทเดียวกัน ในการอ้างถึงตำแหน่งหรือองค์ประกอบเฉพาะในอาร์เรย์เราระบุชื่อของอาร์เรย์และหมายเลขตำแหน่งขององค์ประกอบเฉพาะในอาร์เรย์

ภาพประกอบด้านล่างแสดงอาร์เรย์จำนวนเต็มเรียกว่า C ที่มี 11 องค์ประกอบ คุณอ้างถึงองค์ประกอบใดองค์ประกอบหนึ่งเหล่านี้โดยตั้งชื่ออาร์เรย์ตามด้วยหมายเลขตำแหน่งขององค์ประกอบเฉพาะในวงเล็บเหลี่ยม ([]) หมายเลขตำแหน่งเรียกอย่างเป็นทางการว่าตัวห้อยหรือดัชนี (ตัวเลขนี้ระบุจำนวนองค์ประกอบจากจุดเริ่มต้นของอาร์เรย์) องค์ประกอบแรกมีตัวห้อย 0 (ศูนย์) และบางครั้งเรียกว่าองค์ประกอบศูนย์

ดังนั้นองค์ประกอบของอาร์เรย์ C คือ C [0] (ออกเสียงว่า“ C ย่อยศูนย์”), C [1], C [2] และอื่น ๆ ตัวห้อยสูงสุดในอาร์เรย์ C คือ 10 ซึ่งน้อยกว่าจำนวนองค์ประกอบในอาร์เรย์ 1 รายการ (11) ชื่ออาร์เรย์เป็นไปตามแบบแผนเดียวกันกับชื่อตัวแปรอื่น ๆ

ตัวห้อยต้องเป็นนิพจน์จำนวนเต็มหรือจำนวนเต็ม (ใช้อินทิกรัลชนิดใดก็ได้) หากโปรแกรมใช้นิพจน์เป็นตัวห้อยโปรแกรมจะประเมินนิพจน์เพื่อพิจารณาตัวห้อย ตัวอย่างเช่นถ้าเราถือว่าตัวแปร a เท่ากับ 5 และตัวแปรนั้น b เท่ากับ 6 ดังนั้นคำสั่งจะเพิ่ม 2 ให้กับองค์ประกอบอาร์เรย์ C [11]

ชื่ออาร์เรย์ที่ห้อยลงมาคือ lvalue ซึ่งสามารถใช้ทางด้านซ้ายของการกำหนดได้เช่นเดียวกับชื่อตัวแปรที่ไม่ใช่อาร์เรย์

ให้เราตรวจสอบอาร์เรย์ C ในรูปที่กำหนดให้ละเอียดยิ่งขึ้น ชื่อของอาร์เรย์ทั้งหมดคือ C องค์ประกอบ 11 รายการเรียกว่า C [0] ถึง C [10] ค่าของ C [0] คือ -45 ค่าของ C [1] คือ 6 ค่าของ C [2] คือ 0 ค่าของ C [7] คือ 62 และค่าของ C [10] คือ 78.

ในการพิมพ์ผลรวมของค่าที่มีอยู่ในสามองค์ประกอบแรกของอาร์เรย์ C เราจะเขียน -

Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );

ในการหารค่าของ C [6] ด้วย 2 และกำหนดผลลัพธ์ให้กับตัวแปร x เราจะเขียน -

x = C[ 6 ] / 2;

การประกาศอาร์เรย์

อาร์เรย์ใช้พื้นที่ในหน่วยความจำ ในการระบุประเภทขององค์ประกอบและจำนวนองค์ประกอบที่อาร์เรย์ต้องการให้ใช้การประกาศแบบฟอร์ม -

type arrayName [ arraySize ] ;

คอมไพเลอร์สงวนหน่วยความจำในปริมาณที่เหมาะสม (โปรดจำไว้ว่าการประกาศซึ่งสงวนหน่วยความจำเป็นที่รู้จักกันดีกว่าว่าเป็นคำจำกัดความ) arraySize ต้องเป็นค่าคงที่จำนวนเต็มมากกว่าศูนย์ ตัวอย่างเช่นหากต้องการบอกให้คอมไพเลอร์สงวน 11 องค์ประกอบสำหรับอาร์เรย์จำนวนเต็ม C ให้ใช้การประกาศ -

int C[ 12 ]; // C is an array of 12 integers

อาร์เรย์สามารถประกาศให้มีค่าของชนิดข้อมูลที่ไม่อ้างอิงได้ ตัวอย่างเช่นสามารถใช้สตริงประเภทอาร์เรย์เพื่อจัดเก็บสตริงอักขระ

ตัวอย่างการใช้อาร์เรย์

ส่วนนี้ให้ตัวอย่างมากมายที่แสดงให้เห็นถึงวิธีการประกาศเริ่มต้นและจัดการอาร์เรย์

ตัวอย่างที่ 1: การประกาศ Array และการใช้ Loop เพื่อเริ่มต้นองค์ประกอบของ Array

โปรแกรมประกาศอาร์เรย์จำนวนเต็ม 10 องค์ประกอบ n. บรรทัด a-b ใช้ aForคำสั่งเพื่อเริ่มต้นองค์ประกอบอาร์เรย์เป็นศูนย์ เช่นเดียวกับตัวแปรอัตโนมัติอื่น ๆ อาร์เรย์อัตโนมัติจะไม่เริ่มต้นโดยปริยายเป็นศูนย์ คำสั่งเอาต์พุตแรก (บรรทัด c) แสดงส่วนหัวของคอลัมน์สำหรับคอลัมน์ที่พิมพ์ในคำสั่งต่อมาสำหรับคำสั่ง (บรรทัด d – e) ซึ่งจะพิมพ์อาร์เรย์ในรูปแบบตาราง

Example

int n[ 10 ] ; // n is an array of 10 integers

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
      n[ i ] = 0; // set element at location i to 0
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - จะให้ผลลัพธ์ดังต่อไปนี้ -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
 
        
 
       
      

ตัวอย่างที่ 2: การเริ่มต้น Array ในการประกาศด้วย Initializer List

องค์ประกอบของอาร์เรย์สามารถเริ่มต้นได้ในการประกาศอาร์เรย์โดยทำตามชื่ออาร์เรย์ที่มีเครื่องหมายเท่ากับและรายการเริ่มต้นที่คั่นด้วยเครื่องหมายจุลภาคคั่นด้วยวงเล็บปีกกา โปรแกรมใช้รายการ initializer เพื่อเริ่มต้นอาร์เรย์จำนวนเต็มด้วยค่า 10 (บรรทัด a) และพิมพ์อาร์เรย์ในรูปแบบตาราง (บรรทัด b – c)

Example

// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) {
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - จะให้ผลลัพธ์ดังต่อไปนี้ -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
32
 
27
 
64
 
18
 
95
 
14
 
90
 
70
 
60
 
37
 
 
        
 
       
      

ตัวอย่างที่ 3: การสรุปองค์ประกอบของอาร์เรย์

บ่อยครั้งองค์ประกอบของอาร์เรย์แสดงถึงชุดของค่าที่จะใช้ในการคำนวณ ตัวอย่างเช่นหากองค์ประกอบของอาร์เรย์เป็นตัวแทนของคะแนนสอบอาจารย์อาจต้องการรวมองค์ประกอบของอาร์เรย์และใช้ผลรวมนั้นเพื่อคำนวณค่าเฉลี่ยของชั้นเรียนสำหรับการสอบ โปรแกรมจะรวมค่าที่มีอยู่ในอาร์เรย์จำนวนเต็ม 10 องค์ประกอบa.

Example

const int arraySize = 10; // constant variable indicating size of array
int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;

void setup () {

}
void loop () {
   // sum contents of array a
   for ( int i = 0; i < arraySize; ++i )
      total += a[ i ];
   Serial.print (“Total of array elements : ”) ;
   Serial.print(total) ;
}

Result - จะให้ผลลัพธ์ดังต่อไปนี้ -

Total of array elements: 849

อาร์เรย์มีความสำคัญต่อ Arduino และควรให้ความสนใจมากกว่านี้ แนวคิดที่สำคัญต่อไปนี้ที่เกี่ยวข้องกับอาร์เรย์ควรชัดเจนสำหรับ Arduino -

ส. อบจ.	แนวคิดและคำอธิบาย
1	การส่งอาร์เรย์ไปยังฟังก์ชัน ในการส่งอาร์กิวเมนต์อาร์เรย์ไปยังฟังก์ชันให้ระบุชื่อของอาร์เรย์โดยไม่มีวงเล็บใด ๆ
2	อาร์เรย์หลายมิติ อาร์เรย์ที่มีสองมิติ (เช่นตัวห้อย) มักแสดงถึงตารางของค่าซึ่งประกอบด้วยข้อมูลที่จัดเรียงเป็นแถวและคอลัมน์

หมุดบนบอร์ด Arduino สามารถกำหนดค่าเป็นอินพุตหรือเอาต์พุตได้ เราจะอธิบายการทำงานของพินในโหมดเหล่านั้น สิ่งสำคัญคือต้องสังเกตว่าพินอะนาล็อก Arduino ส่วนใหญ่อาจได้รับการกำหนดค่าและใช้งานในลักษณะเดียวกับพินดิจิทัล

พินที่กำหนดค่าเป็น INPUT

โดยค่าเริ่มต้นหมุด Arduino ถูกกำหนดค่าเป็นอินพุตดังนั้นจึงไม่จำเป็นต้องประกาศอย่างชัดเจนว่าเป็นอินพุตด้วย pinMode()เมื่อคุณใช้เป็นอินพุต พินที่กำหนดค่าด้วยวิธีนี้จะกล่าวได้ว่าอยู่ในสถานะที่มีความต้านทานสูง พินอินพุตสร้างความต้องการเพียงเล็กน้อยในวงจรที่พวกเขากำลังสุ่มตัวอย่างเทียบเท่ากับตัวต้านทานแบบอนุกรมที่ 100 เมกะโอห์มที่ด้านหน้าของพิน

ซึ่งหมายความว่าต้องใช้กระแสน้อยมากในการเปลี่ยนพินอินพุตจากสถานะหนึ่งไปยังอีกสถานะหนึ่ง สิ่งนี้ทำให้พินมีประโยชน์สำหรับงานต่างๆเช่นการใช้เซ็นเซอร์สัมผัสแบบ capacitive หรือการอ่าน LED เป็นโฟโตไดโอด

พินที่กำหนดค่าเป็น pinMode (พิน, อินพุต) โดยไม่มีอะไรเชื่อมต่อกับพวกเขาหรือมีสายไฟที่เชื่อมต่อกับพวกเขาที่ไม่ได้เชื่อมต่อกับวงจรอื่นรายงานการเปลี่ยนแปลงที่ดูเหมือนสุ่มในสถานะพินรับสัญญาณรบกวนทางไฟฟ้าจากสภาพแวดล้อมหรือการเชื่อมต่อสถานะ ของพินใกล้เคียง

ตัวต้านทานแบบดึงขึ้น

ตัวต้านทานแบบดึงขึ้นมักมีประโยชน์ในการบังคับขาอินพุตไปยังสถานะที่ทราบหากไม่มีอินพุตอยู่ สามารถทำได้โดยการเพิ่มตัวต้านทานแบบดึงขึ้น (ถึง + 5V) หรือตัวต้านทานแบบดึงลง (ตัวต้านทานต่อกราวด์) บนอินพุต ตัวต้านทาน 10K เป็นค่าที่ดีสำหรับตัวต้านทานแบบดึงขึ้นหรือแบบดึงลง

ใช้ตัวต้านทานแบบดึงขึ้นในตัวพร้อมพินที่กำหนดค่าเป็นอินพุต

มีตัวต้านทานแบบดึงขึ้น 20,000 ตัวในชิป Atmega ที่สามารถเข้าถึงได้จากซอฟต์แวร์ ตัวต้านทานแบบดึงขึ้นในตัวเหล่านี้สามารถเข้าถึงได้โดยการตั้งค่าpinMode()เป็น INPUT_PULLUP สิ่งนี้จะเปลี่ยนพฤติกรรมของโหมด INPUT ได้อย่างมีประสิทธิภาพโดยที่ HIGH หมายถึงเซ็นเซอร์ปิดอยู่และ LOW หมายถึงเซ็นเซอร์เปิดอยู่ ค่าของการดึงขึ้นนี้ขึ้นอยู่กับไมโครคอนโทรลเลอร์ที่ใช้ บนบอร์ดที่ใช้ AVR ส่วนใหญ่จะรับประกันว่าค่าอยู่ระหว่าง20kΩถึง50kΩ บน Arduino Due อยู่ระหว่าง50kΩถึง150kΩ สำหรับค่าที่แน่นอนโปรดดูแผ่นข้อมูลของไมโครคอนโทรลเลอร์บนบอร์ดของคุณ

เมื่อเชื่อมต่อเซ็นเซอร์กับพินที่กำหนดค่าด้วย INPUT_PULLUP ปลายอีกด้านหนึ่งควรเชื่อมต่อกับกราวด์ ในกรณีของสวิตช์ธรรมดาจะทำให้พินอ่าน HIGH เมื่อสวิตช์เปิดอยู่และ LOW เมื่อกดสวิตช์ ตัวต้านทานแบบดึงขึ้นให้กระแสไฟเพียงพอที่จะทำให้ไฟ LED สลัวที่เชื่อมต่อกับพินที่กำหนดค่าเป็นอินพุต หากไฟ LED ในโปรเจ็กต์ดูเหมือนจะใช้งานได้ แต่มีแสงสลัวมากก็เป็นไปได้ว่าจะเกิดอะไรขึ้น

รีจิสเตอร์เดียวกัน (ตำแหน่งหน่วยความจำชิปภายใน) ที่ควบคุมว่าพินสูงหรือต่ำควบคุมตัวต้านทานแบบดึงขึ้น ดังนั้นพินที่กำหนดค่าให้เปิดตัวต้านทานแบบดึงขึ้นเมื่อพินอยู่ในโหมด INPUT จะมีการกำหนดค่าพินเป็น HIGH หากพินถูกเปลี่ยนเป็นโหมดเอาท์พุทด้วย pinMode () สิ่งนี้ทำงานในทิศทางอื่นเช่นกันและขาเอาต์พุตที่อยู่ในสถานะสูงจะมีชุดตัวต้านทานแบบดึงขึ้นหากเปลี่ยนเป็นอินพุตด้วย pinMode ()

Example

pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor
pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor

พินกำหนดค่าเป็น OUTPUT

พินที่กำหนดค่าเป็น OUTPUT ด้วย pinMode () ถูกกล่าวว่าอยู่ในสถานะอิมพีแดนซ์ต่ำ ซึ่งหมายความว่าสามารถจ่ายกระแสให้กับวงจรอื่น ๆ ได้เป็นจำนวนมาก พิน Atmega สามารถจ่ายกระแสไฟฟ้า (ให้กระแสบวก) หรือจม (ให้กระแสไฟฟ้าลบ) ได้ถึง 40 mA (มิลลิแอมป์) ของกระแสไปยังอุปกรณ์ / วงจรอื่น ๆ นี่เป็นกระแสเพียงพอที่จะทำให้ LED สว่างขึ้น (อย่าลืมตัวต้านทานแบบอนุกรม) หรือเรียกใช้เซ็นเซอร์จำนวนมาก แต่กระแสไฟฟ้าไม่เพียงพอที่จะรันรีเลย์โซลีนอยด์หรือมอเตอร์

การพยายามเรียกใช้อุปกรณ์กระแสสูงจากพินเอาต์พุตอาจทำให้ทรานซิสเตอร์เอาต์พุตในพินเสียหายหรือทำลายชิป Atmega ทั้งหมดได้ บ่อยครั้งสิ่งนี้ส่งผลให้พิน "ตาย" ในไมโครคอนโทรลเลอร์ แต่ชิปที่เหลือยังทำงานได้อย่างเพียงพอ ด้วยเหตุนี้จึงเป็นความคิดที่ดีที่จะเชื่อมต่อพิน OUTPUT กับอุปกรณ์อื่น ๆ ผ่านตัวต้านทาน470Ωหรือ 1k เว้นแต่จะต้องใช้กระแสไฟฟ้าสูงสุดที่ดึงออกมาจากพินสำหรับแอพพลิเคชั่นเฉพาะ

pinMode () ฟังก์ชัน

ฟังก์ชัน pinMode () ใช้เพื่อกำหนดค่าพินเฉพาะให้ทำงานเป็นอินพุตหรือเอาต์พุต เป็นไปได้ที่จะเปิดใช้งานตัวต้านทานแบบดึงขึ้นภายในด้วยโหมด INPUT_PULLUP นอกจากนี้โหมด INPUT จะปิดการใช้งานพูลอัพภายในอย่างชัดเจน

pinMode () ไวยากรณ์ของฟังก์ชัน

Void setup () {
   pinMode (pin , mode);
}

• pin - จำนวนพินที่คุณต้องการตั้งค่าโหมด

• mode - INPUT, OUTPUT หรือ INPUT_PULLUP

Example

int button = 5 ; // button connected to pin 5
int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(button , INPUT_PULLUP); 
   // set the digital pin as input with pull-up resistor
   pinMode(button , OUTPUT); // set the digital pin as output
}

void setup () {
   If (digitalRead(button ) == LOW) // if button pressed {
      digitalWrite(LED,HIGH); // turn on led
      delay(500); // delay for 500 ms
      digitalWrite(LED,LOW); // turn off led
      delay(500); // delay for 500 ms
   }
}

digitalWrite () ฟังก์ชัน

digitalWrite()ฟังก์ชันใช้ในการเขียนค่าสูงหรือค่าต่ำไปยังพินดิจิทัล หากกำหนดค่าพินเป็น OUTPUT ด้วยpinMode ()แรงดันไฟฟ้าจะถูกกำหนดเป็นค่าที่สอดคล้องกัน: 5V (หรือ 3.3V บนบอร์ด 3.3V) สำหรับ HIGH, 0V (กราวด์) สำหรับ LOW หากกำหนดค่าพินเป็น INPUT digitalWrite () จะเปิดใช้งาน (HIGH) หรือปิดใช้งาน (LOW) พูลอัพภายในของพินอินพุต ขอแนะนำให้ตั้งค่าpinMode ()เป็น INPUT_PULLUP เพื่อเปิดใช้งานตัวต้านทานแบบดึงขึ้นภายใน

หากคุณไม่ได้ตั้งค่า pinMode () เป็น OUTPUT และเชื่อมต่อ LED เข้ากับพินเมื่อเรียก digitalWrite (HIGH) ไฟ LED อาจหรี่ลง หากไม่มีการตั้งค่า pinMode () อย่างชัดเจน digitalWrite () จะเปิดใช้งานตัวต้านทานแบบดึงขึ้นภายในซึ่งทำหน้าที่เหมือนตัวต้านทาน จำกัด กระแสขนาดใหญ่

digitalWrite () ไวยากรณ์ของฟังก์ชัน

Void loop() {
   digitalWrite (pin ,value);
}

• pin - จำนวนพินที่คุณต้องการตั้งค่าโหมด

• value - สูงหรือต่ำ

Example

int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(LED, OUTPUT); // set the digital pin as output
}

void setup () { 
   digitalWrite(LED,HIGH); // turn on led
   delay(500); // delay for 500 ms
   digitalWrite(LED,LOW); // turn off led
   delay(500); // delay for 500 ms
}

ฟังก์ชัน analogRead ()

Arduino สามารถตรวจจับว่ามีแรงดันไฟฟ้าที่ใช้กับหมุดตัวใดตัวหนึ่งหรือไม่และรายงานผ่านฟังก์ชัน digitalRead () มีความแตกต่างระหว่างเซ็นเซอร์เปิด / ปิด (ซึ่งตรวจจับการมีอยู่ของวัตถุ) และเซ็นเซอร์อะนาล็อกซึ่งค่าจะเปลี่ยนแปลงอย่างต่อเนื่อง ในการอ่านเซ็นเซอร์ประเภทนี้เราจำเป็นต้องมีพินประเภทอื่น

ในส่วนล่างขวาของบอร์ด Arduino คุณจะเห็นหมุดหกตัวที่มีเครื่องหมาย "Analog In" พินพิเศษเหล่านี้ไม่เพียง แต่บอกว่ามีแรงดันไฟฟ้าที่ใช้กับพวกมันเท่านั้น แต่ยังรวมถึงค่า โดยใช้ไฟล์analogRead() เราสามารถอ่านแรงดันไฟฟ้าที่ใช้กับหมุดตัวใดตัวหนึ่งได้

ฟังก์ชันนี้จะส่งกลับตัวเลขระหว่าง 0 ถึง 1023 ซึ่งแสดงถึงแรงดันไฟฟ้าระหว่าง 0 ถึง 5 โวลต์ ตัวอย่างเช่นหากมีแรงดันไฟฟ้า 2.5 V ที่ใช้กับพินหมายเลข 0 analogRead (0) จะส่งกลับ 512

analogRead () ของฟังก์ชัน Syntax

analogRead(pin);

• pin - จำนวนพินอินพุตแบบอะนาล็อกที่จะอ่าน (0 ถึง 5 บนบอร์ดส่วนใหญ่, 0 ถึง 7 ใน Mini และ Nano, 0 ถึง 15 บน Mega)

Example

int analogPin = 3;//potentiometer wiper (middle terminal) 
   // connected to analog pin 3 
int val = 0; // variable to store the value read

void setup() {
   Serial.begin(9600); // setup serial
} 

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

ในบทนี้เราจะเรียนรู้ฟังก์ชันอินพุตและเอาต์พุตขั้นสูง

analogReference () ฟังก์ชัน

กำหนดค่าแรงดันอ้างอิงที่ใช้สำหรับอินพุตแบบอะนาล็อก (เช่นค่าที่ใช้เป็นด้านบนสุดของช่วงอินพุต) ตัวเลือกคือ -

• DEFAULT - อ้างอิงอะนาล็อกเริ่มต้น 5 โวลต์ (บนบอร์ด 5V Arduino) หรือ 3.3 โวลต์ (บนบอร์ด 3.3V Arduino)

• INTERNAL - การอ้างอิงในตัวเท่ากับ 1.1 โวลต์บน ATmega168 หรือ ATmega328 และ 2.56 โวลต์บน ATmega8 (ไม่มีใน Arduino Mega)

• INTERNAL1V1 - การอ้างอิง 1.1V ในตัว (Arduino Mega เท่านั้น)

• INTERNAL2V56 - การอ้างอิง 2.56V ในตัว (Arduino Mega เท่านั้น)

• EXTERNAL - ใช้แรงดันไฟฟ้าที่ใช้กับขา AREF (0 ถึง 5V เท่านั้น) เป็นข้อมูลอ้างอิง

analogReference () ไวยากรณ์ของฟังก์ชัน

analogReference (type);

type - สามารถใช้ประเภทใดก็ได้ดังต่อไปนี้ (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56, EXTERNAL)

อย่าใช้อะไรที่น้อยกว่า 0V หรือมากกว่า 5V สำหรับแรงดันอ้างอิงภายนอกที่ขา AREF หากคุณใช้การอ้างอิงภายนอกบนพิน AREF คุณต้องตั้งค่าการอ้างอิงอะนาล็อกเป็น EXTERNAL ก่อนที่จะเรียกไฟล์analogRead()ฟังก์ชัน มิฉะนั้นคุณจะลัดวงจรแรงดันอ้างอิงที่ใช้งานอยู่ (สร้างขึ้นภายใน) และพิน AREF ซึ่งอาจทำให้ไมโครคอนโทรลเลอร์บนบอร์ด Arduino ของคุณเสียหายได้

หรือคุณสามารถเชื่อมต่อแรงดันอ้างอิงภายนอกกับพิน AREF ผ่านตัวต้านทาน 5K ทำให้คุณสามารถสลับระหว่างแรงดันอ้างอิงภายนอกและภายในได้

โปรดทราบว่าตัวต้านทานจะเปลี่ยนแรงดันไฟฟ้าที่ใช้เป็นข้อมูลอ้างอิงเนื่องจากมีตัวต้านทาน 32K ภายในที่ขา AREF ทั้งสองทำหน้าที่เป็นตัวแบ่งแรงดันไฟฟ้า ตัวอย่างเช่น 2.5V ที่ใช้ผ่านตัวต้านทานจะให้ผล 2.5 * 32 / (32 + 5) = ~ 2.2V ที่ขา AREF

Example

int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3 
int val = 0; // variable to store the read value

void setup() {
   Serial.begin(9600); // setup serial
   analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only) 
      // is used as the reference.
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

ข้อมูลทั้งหมดจะถูกป้อนลงในคอมพิวเตอร์เป็นอักขระซึ่งรวมถึงตัวอักษรตัวเลขและสัญลักษณ์พิเศษต่างๆ ในส่วนนี้เราจะพูดถึงความสามารถของ C ++ สำหรับการตรวจสอบและจัดการอักขระแต่ละตัว

ไลบรารีการจัดการอักขระประกอบด้วยฟังก์ชันต่างๆที่ดำเนินการทดสอบที่เป็นประโยชน์และการปรับเปลี่ยนข้อมูลอักขระ แต่ละฟังก์ชันจะรับอักขระแสดงเป็น int หรือ EOF เป็นอาร์กิวเมนต์ อักขระมักถูกจัดการเป็นจำนวนเต็ม

โปรดจำไว้ว่าโดยปกติแล้ว EOF จะมีค่า –1 และสถาปัตยกรรมฮาร์ดแวร์บางอย่างไม่อนุญาตให้เก็บค่าลบในตัวแปรถ่าน ดังนั้นฟังก์ชันการจัดการอักขระจึงจัดการอักขระเป็นจำนวนเต็ม

ตารางต่อไปนี้สรุปฟังก์ชันของไลบรารีการจัดการอักขระ เมื่อใช้ฟังก์ชันจากไลบรารีการจัดการอักขระให้รวมไฟล์<cctype> หัวข้อ.

ส.	ต้นแบบและคำอธิบาย
1	int isdigit( int c ) ส่งคืน 1 ถ้า c เป็นตัวเลขและเป็น 0
2	int isalpha( int c ) ส่งคืน 1 ถ้า c เป็นตัวอักษรและเป็น 0
3	int isalnum( int c ) ส่งคืน 1 ถ้า c เป็นตัวเลขหรือตัวอักษรและเป็น 0
4	int isxdigit( int c ) ส่งคืน 1 ถ้า c เป็นอักขระเลขฐานสิบหกและเป็น 0 (ดูภาคผนวกงระบบตัวเลขสำหรับคำอธิบายโดยละเอียดเกี่ยวกับเลขฐานสองฐานแปดฐานสิบและเลขฐานสิบหก)
5	int islower( int c ) ส่งคืน 1 ถ้า c เป็นตัวอักษรตัวพิมพ์เล็กและเป็น 0
6	int isupper( int c ) ส่งกลับ 1 ถ้า c เป็นอักษรตัวพิมพ์ใหญ่ 0 มิฉะนั้น
7	int isspace( int c ) ส่งคืน 1 ถ้า c เป็นอักขระช่องว่าง - ขึ้นบรรทัดใหม่ ('\ n') ช่องว่าง (''), ฟีดฟอร์ม ('\ f'), การคืนค่าขนส่ง ('\ r'), แท็บแนวนอน ('\ t') หรือแท็บแนวตั้ง ('\ v') - และ 0 มิฉะนั้น
8	int iscntrl( int c ) ส่งคืน 1 ถ้า c เป็นอักขระควบคุมเช่น newline ('\ n'), form feed ('\ f'), carriage return ('\ r'), horizontal tab ('\ t'), vertical tab (' \ v '), alert (' \ a ') หรือ backspace (' \ b ') - และ 0
9	int ispunct( int c ) ส่งคืน 1 ถ้า c เป็นอักขระการพิมพ์อื่นที่ไม่ใช่ช่องว่างตัวเลขหรือตัวอักษรและ 0
10	int isprint( int c ) ส่งคืน 1 ถ้า c เป็นอักขระการพิมพ์รวมช่องว่าง ('') และ 0 มิฉะนั้น
11	int isgraph( int c ) ส่งคืน 1 หาก c เป็นอักขระการพิมพ์อื่นที่ไม่ใช่ช่องว่าง ('') และ 0 มิฉะนั้น

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้ฟังก์ชัน isdigit, isalpha, isalnum และ isxdigit. ฟังก์ชันisdigitพิจารณาว่าอาร์กิวเมนต์เป็นตัวเลข (0–9) หรือไม่ ฟังก์ชั่นisalphaพิจารณาว่าอาร์กิวเมนต์เป็นอักษรตัวพิมพ์ใหญ่ (AZ) หรืออักษรตัวพิมพ์เล็ก (a – z) ฟังก์ชั่นisalnumพิจารณาว่าอาร์กิวเมนต์เป็นตัวพิมพ์ใหญ่ตัวพิมพ์เล็กหรือตัวเลข ฟังก์ชันisxdigit พิจารณาว่าอาร์กิวเมนต์เป็นเลขฐานสิบหก (A – F, a – f, 0–9) หรือไม่

ตัวอย่าง 1

void setup () {
   Serial.begin (9600);
   Serial.print ("According to isdigit:\r");
   Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
   Serial.print (" digit\r" );
   Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
   Serial.print (" digit\r");
   Serial.print ("\rAccording to isalpha:\r" );
   Serial.print (isalpha('A' ) ?"A is a": "A is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A' ) ?"b is a": "b is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A') ?"& is a": "& is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
   Serial.print (" letter\r");
   Serial.print ("\rAccording to isalnum:\r");
   Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

   Serial.print (" digit or a letter\r" );
   Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
   Serial.print (" digit or a letter\r");
   Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
   Serial.print (" digit or a letter\r");
   Serial.print ("\rAccording to isxdigit:\r");
   Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
   
}

void loop () {

}

ผลลัพธ์

According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit

$ is not a hexadecimal digit
f is a hexadecimal digit

เราใช้ตัวดำเนินการตามเงื่อนไข (?:)ด้วยแต่ละฟังก์ชันเพื่อกำหนดว่าสตริง "เป็น" หรือสตริง "ไม่ใช่" ควรจะพิมพ์ในเอาต์พุตสำหรับอักขระแต่ละตัวที่ทดสอบ ตัวอย่างเช่นบรรทัดa บ่งชี้ว่าถ้า '8' เป็นตัวเลขเช่นถ้า isdigitส่งกลับค่าจริง (ไม่ใช่ศูนย์) - พิมพ์สตริง "8 is a" ถ้า '8' ไม่ใช่ตัวเลข (เช่นถ้าisdigit ส่งกลับ 0) สตริง "8 ไม่ใช่ a" ถูกพิมพ์

ตัวอย่าง 2

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้ฟังก์ชัน islower และ isupper. ฟังก์ชั่นislowerพิจารณาว่าอาร์กิวเมนต์เป็นอักษรตัวพิมพ์เล็ก (a – z) หรือไม่ ฟังก์ชันisupper พิจารณาว่าอาร์กิวเมนต์เป็นอักษรตัวพิมพ์ใหญ่ (A – Z) หรือไม่

int thisChar = 0xA0;

void setup () {
   Serial.begin (9600);
   Serial.print ("According to islower:\r") ;
   Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
   Serial.print ("lowercase letter\r");
   Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
   Serial.print ("lowercase letter\r");

   Serial.print ("\rAccording to isupper:\r") ;
   Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
   Serial.print ( " uppercase letter\r" );
   Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
   Serial.print ("uppercase letter\r ");
}

void setup () {

}

ผลลัพธ์

According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter

ตัวอย่างที่ 3

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้ฟังก์ชัน isspace, iscntrl, ispunct, isprint และ isgraph.

• ฟังก์ชั่น isspace พิจารณาว่าอาร์กิวเมนต์เป็นอักขระช่องว่างเช่น space (''), form feed ('\ f'), newline ('\ n'), carriage return ('\ r'), แท็บแนวนอน ('\ t ') หรือแท็บแนวตั้ง (' \ v ')

• ฟังก์ชั่น iscntrl พิจารณาว่าอาร์กิวเมนต์เป็นอักขระควบคุมเช่นแท็บแนวนอน ('\ t'), แท็บแนวตั้ง ('\ v'), ฟีดแบบฟอร์ม ('\ f'), alert ('\ a'), backspace ('\ b '), carriage return (' \ r ') หรือ newline (' \ n ')

• ฟังก์ชั่น ispunct พิจารณาว่าอาร์กิวเมนต์เป็นอักขระการพิมพ์อื่นที่ไม่ใช่ช่องว่างตัวเลขหรือตัวอักษรเช่น $, #, (,), [,], {,},;,: หรือ%

• ฟังก์ชั่น isprint พิจารณาว่าอาร์กิวเมนต์เป็นอักขระที่สามารถแสดงบนหน้าจอได้หรือไม่ (รวมถึงอักขระช่องว่าง)

• ฟังก์ชั่น isgraph ทดสอบอักขระเดียวกันกับ isprint แต่ไม่รวมอักขระช่องว่าง

void setup () {
   Serial.begin (9600);
   Serial.print ( " According to isspace:\rNewline ") ;
   Serial.print (isspace( '\n' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\rHorizontal tab") ;
   Serial.print (isspace( '\t' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\n") ;
   Serial.print (isspace('%')? " % is a" : " % is not a" );
   
   Serial.print ( " \rAccording to iscntrl:\rNewline") ;
   Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
   Serial.print (" control character\r");
   Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
   Serial.print (" control character\r");
   Serial.print ("\rAccording to ispunct:\r");
   Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
   Serial.print (" punctuation character\r");
   Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
   Serial.print ("punctuation character\r");
   Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
   Serial.print ("punctuation character\r");

   Serial.print ( "\r According to isprint:\r");
   Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
   Serial.print (" printing character\rAlert ");
   Serial.print (isprint('\a' ) ?" is a" : " is not a" );
   Serial.print (" printing character\rSpace ");
   Serial.print (isprint(' ' ) ?" is a" : " is not a" );
   Serial.print (" printing character\r");
   
   Serial.print ("\r According to isgraph:\r");
   Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
   Serial.print ("printing character other than a space\rSpace ");
   Serial.print (isgraph (' ') ?" is a" : " is not a" );
   Serial.print ("printing character other than a space ");
}

void loop () {

}

ผลลัพธ์

According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space

ห้องสมุด Arduino Math (math.h) ประกอบด้วยฟังก์ชันทางคณิตศาสตร์ที่มีประโยชน์มากมายสำหรับการจัดการตัวเลขทศนิยม

แมโครไลบรารี

ต่อไปนี้เป็นมาโครที่กำหนดไว้ในส่วนหัวทางคณิตศาสตร์ h -

ด้านล่างนี้คือรายการมาโครที่กำหนดไว้ในส่วนหัวทางคณิตศาสตร์ h

มาโคร	มูลค่า	คำอธิบาย
ฉัน	2.7182818284590452354	ค่าคงที่ e.
M_LOG2E	1.4426950408889634074 / * log_2 จ * /	ลอการิทึมของ e ถึงฐาน 2
M_1_PI	0.31830988618379067154 / * 1 / ปี่ * /	ค่าคงที่ 1 / pi
M_2_PI	0.63661977236758134308 / * 2 / ปี่ * /	ค่าคงที่ 2 / pi
M_2_SQRTPI	1.12837916709551257390 / * 2 / sqrt (ปี่) * /	ค่าคงที่ 2 / sqrt (pi)
M_LN10	2.30258509299404568402 / * log_e 10 * /	ลอการิทึมธรรมชาติของ 10
M_LN2	0.69314718055994530942 / * log_e 2 * /	ลอการิทึมธรรมชาติของ 2
M_LOG10E	0.43429448190325182765 / * log_10 จ * /	ลอการิทึมของ e ถึงฐาน 10
M_PI	3.14159265358979323846 / * ปี่ * /	ปี่คง
M_PI_2	3.3V1.57079632679489661923 / * ปี่ / 2 * /	ค่าคงที่ pi / 2
M_PI_4	0.78539816339744830962 / * ปี่ / 4 * /	ค่าคงที่ pi / 4
M_SQRT1_2	0.70710678118654752440 / * 1 / sqrt (2) * /	ค่าคงที่ 1 / sqrt (2)
M_SQRT2	1.41421356237309504880 / * sqrt (2) * /	รากที่สองของ 2
acosf	-	นามแฝงสำหรับฟังก์ชัน acos ()
asinf	-	นามแฝงสำหรับฟังก์ชัน asin ()
atan2f	-	นามแฝงสำหรับฟังก์ชัน atan2 ()
cbrtf	-	นามแฝงสำหรับฟังก์ชัน cbrt ()
ceilf	-	นามแฝงสำหรับฟังก์ชัน ceil ()
copysignf	-	นามแฝงสำหรับฟังก์ชัน copysign ()
coshf	-	นามแฝงสำหรับฟังก์ชัน cosh ()
expf	-	นามแฝงสำหรับฟังก์ชัน exp ()
fabsf	-	นามแฝงสำหรับฟังก์ชัน fabs ()
fdimf	-	นามแฝงสำหรับฟังก์ชัน fdim ()
ชั้น f	-	นามแฝงสำหรับฟังก์ชัน floor ()
fmaxf	-	นามแฝงสำหรับฟังก์ชัน fmax ()
fminf	-	นามแฝงสำหรับฟังก์ชัน fmin ()
fmodf	-	นามแฝงสำหรับฟังก์ชัน fmod ()
frexpf	-	นามแฝงสำหรับฟังก์ชัน frexp ()
hypotf	-	นามแฝงสำหรับฟังก์ชัน hypot ()
INFINITY	-	ค่าคงที่ INFINITY
isfinitef	-	นามแฝงสำหรับฟังก์ชัน isfinite ()
isinff	-	นามแฝงสำหรับฟังก์ชัน isinf ()
isnanf	-	นามแฝงสำหรับฟังก์ชัน isnan ()
ldexpf	-	นามแฝงสำหรับฟังก์ชัน ldexp ()
log10f	-	นามแฝงสำหรับฟังก์ชัน log10 ()
logf	-	นามแฝงสำหรับฟังก์ชัน log ()
lrintf	-	นามแฝงสำหรับฟังก์ชัน lrint ()
lroundf	-	นามแฝงสำหรับฟังก์ชัน lround ()

ฟังก์ชั่นห้องสมุด

ฟังก์ชันต่อไปนี้กำหนดไว้ในส่วนหัว math.h -

ด้านล่างนี้คือรายการของฟังก์ชันที่กำหนดไว้ในส่วนหัวทางคณิตศาสตร์ h

ส.	ฟังก์ชั่นและคำอธิบายไลบรารี
1	double acos (double __x) ฟังก์ชัน acos () คำนวณค่าหลักของอาร์คโคไซน์ของ __x ค่าที่ส่งคืนอยู่ในช่วงเรเดียน [0, pi] เกิดข้อผิดพลาดของโดเมนสำหรับอาร์กิวเมนต์ที่ไม่อยู่ในช่วง [-1, +1]
2	double asin (double __x) ฟังก์ชัน asin () คำนวณค่าหลักของอาร์กไซน์ของ __x ค่าที่ส่งคืนอยู่ในช่วง [-pi / 2, pi / 2] เรเดียน เกิดข้อผิดพลาดของโดเมนสำหรับอาร์กิวเมนต์ที่ไม่อยู่ในช่วง [-1, +1]
3	double atan (double __x) ฟังก์ชัน atan () คำนวณค่าหลักของอาร์กแทนเจนต์ของ __x ค่าที่ส่งคืนอยู่ในช่วง [-pi / 2, pi / 2] เรเดียน
4	double atan2 (double __y, double __x) ฟังก์ชัน atan2 () คำนวณค่าหลักของส่วนโค้งแทนเจนต์ของ __y / __x โดยใช้สัญลักษณ์ของอาร์กิวเมนต์ทั้งสองเพื่อกำหนดกำลังสองของค่าที่ส่งคืน ค่าที่ส่งคืนอยู่ในช่วงเรเดียน [-pi, + pi]
5	double cbrt (double __x) ฟังก์ชัน cbrt () ส่งคืนคิวบ์รูทของ __x
6	double ceil (double __x) ฟังก์ชัน ceil () จะส่งกลับค่าอินทิกรัลที่เล็กที่สุดที่มากกว่าหรือเท่ากับ __x ซึ่งแสดงเป็นตัวเลขทศนิยม
7	static double copysign (double __x, double __y) ฟังก์ชัน copysign () ส่งคืน __x แต่มีเครื่องหมาย __y ทำงานได้แม้ว่า __x หรือ __y จะเป็น NaN หรือศูนย์ก็ตาม
8	double cos(double __x) ฟังก์ชัน cos () จะส่งกลับค่าโคไซน์ของ __x ซึ่งวัดเป็นเรเดียน
9	double cosh (double __x) ฟังก์ชัน cosh () ส่งกลับค่าไฮเพอร์โบลิกโคไซน์ของ __x
10	double exp (double __x) ฟังก์ชัน exp () ส่งกลับค่าเอ็กซ์โพเนนเชียลของ __x
11	double fabs (double __x) ฟังก์ชัน fabs () คำนวณค่าสัมบูรณ์ของเลขทศนิยม __x
12	double fdim (double __x, double __y) ฟังก์ชัน fdim () ส่งกลับค่าสูงสุด (__ x - __y, 0) ถ้า __x หรือ __y หรือทั้งสองเป็น NaN จะส่งคืน NaN
13	double floor (double __x) ฟังก์ชัน floor () จะส่งกลับค่าอินทิกรัลที่ใหญ่ที่สุดที่น้อยกว่าหรือเท่ากับ __x ซึ่งแสดงเป็นตัวเลขทศนิยม
14	double fma (double __x, double __y, double __z) ฟังก์ชัน fma () ดำเนินการคูณจุดลอยตัว นี่คือการดำเนินการ (__x * __y) + __z แต่ผลลัพธ์ระดับกลางจะไม่ปัดเศษเป็นประเภทปลายทาง บางครั้งสิ่งนี้สามารถปรับปรุงความแม่นยำของการคำนวณได้
15	double fmax (double __x, double __y) ฟังก์ชัน fmax () ส่งคืนค่าที่มากกว่าของสองค่า __x และ __y ถ้าอาร์กิวเมนต์เป็น NaN อาร์กิวเมนต์อื่นจะถูกส่งกลับ ถ้าอาร์กิวเมนต์ทั้งสองเป็น NaN ระบบจะส่งคืน NaN
16	double fmin (double __x, double __y) ฟังก์ชัน fmin () ส่งคืนค่าที่น้อยกว่าของสองค่า __x และ __y ถ้าอาร์กิวเมนต์เป็น NaN อาร์กิวเมนต์อื่นจะถูกส่งกลับ ถ้าอาร์กิวเมนต์ทั้งสองเป็น NaN ระบบจะส่งคืน NaN
17	double fmod (double __x, double__y) ฟังก์ชั่น fmod () ส่งคืนค่าทศนิยมที่เหลือของ __x / __y
18	double frexp (double __x, int * __pexp) ฟังก์ชัน frexp () จะแบ่งตัวเลขทศนิยมออกเป็นเศษส่วนปกติและกำลังรวมของ 2 โดยจะเก็บจำนวนเต็มไว้ในวัตถุ int ที่ชี้โดย __pexp ถ้า __x เป็นเลขทศนิยมปกติฟังก์ชัน frexp () จะส่งกลับค่า v โดยที่ v มีขนาดในช่วงเวลา [1/2, 1) หรือศูนย์และ __x เท่ากับ v คูณ 2 ยกกำลัง __pexp ถ้า __x เป็นศูนย์ผลลัพธ์ทั้งสองส่วนจะเป็นศูนย์ ถ้า __x ไม่ใช่จำนวน จำกัด frexp () จะส่งคืน __x ตามที่เป็นอยู่และเก็บ 0 โดย __pexp Note - การใช้งานนี้อนุญาตให้ตัวชี้ศูนย์เป็นคำสั่งในการข้ามการจัดเก็บเลขชี้กำลัง
19	double hypot (double __x, double__y) ฟังก์ชัน hypot () ส่งกลับ sqrt (__ x * __ x + __y * __ y) นี่คือความยาวของด้านตรงข้ามมุมฉากของสามเหลี่ยมมุมฉากที่มีด้านยาว __x และ __y หรือระยะห่างของจุด (__x, __y) จากจุดกำเนิด การใช้ฟังก์ชันนี้แทนสูตรโดยตรงนั้นชาญฉลาดเนื่องจากข้อผิดพลาดมีขนาดเล็กกว่ามาก ไม่มีส่วนเกินขนาดเล็ก __x และ __y ไม่มีการล้นหากผลลัพธ์อยู่ในช่วง
20	static int isfinite (double __x) ฟังก์ชัน isfinite () จะส่งคืนค่าที่ไม่ใช่ศูนย์ถ้า __x คือ จำกัด : ไม่ใช่บวกหรือลบอินฟินิตี้และไม่ NaN.
21	int isinf (double __x) ฟังก์ชัน isinf () จะคืนค่า 1 ถ้าอาร์กิวเมนต์ __x เป็นค่าอินฟินิตี้บวก -1 ถ้า __x เป็นค่าอินฟินิตี้ลบและเป็น 0 Note - GCC 4.3 สามารถแทนที่ฟังก์ชันนี้ด้วยโค้ดอินไลน์ที่ส่งคืนค่า 1 สำหรับ infinities ทั้งสอง (gcc bug # 35509)
22	int isnan (double __x) ฟังก์ชัน isnan () ส่งกลับ 1 ถ้าอาร์กิวเมนต์ __x แสดงถึง "ไม่ใช่-a-number" (NaN) วัตถุมิฉะนั้น 0
23	double ldexp (double __x, int __exp ) ฟังก์ชัน ldexp () คูณจำนวนทศนิยมด้วยกำลังอินทิกรัลของ 2 จะส่งคืนค่า __x คูณ 2 ยกกำลัง __exp
24	double log (double __x) ฟังก์ชัน log () ส่งคืนลอการิทึมธรรมชาติของอาร์กิวเมนต์ __x
25	double log10(double __x) ฟังก์ชัน log10 () จะส่งคืนลอการิทึมของอาร์กิวเมนต์ __x เป็นฐาน 10
26	long lrint (double __x) ฟังก์ชัน lrint () จะปัดเศษ __x เป็นจำนวนเต็มที่ใกล้ที่สุดโดยปัดเศษกรณีครึ่งทางไปยังทิศทางจำนวนเต็มคู่ (นั่นคือทั้ง 1.5 และ 2.5 ค่าจะถูกปัดเศษเป็น 2) ฟังก์ชันนี้คล้ายกับฟังก์ชัน rint () แต่จะแตกต่างกันในประเภทของค่าที่ส่งคืนและสามารถเกิดโอเวอร์โฟลว์ได้ Returns ค่าจำนวนเต็มยาวที่ปัดเศษ ถ้า __x ไม่ใช่จำนวน จำกัด หรือโอเวอร์โฟลว์การรับรู้นี้จะส่งคืนค่า LONG_MIN (0x80000000)
27	long lround (double __x) ฟังก์ชัน lround () จะปัดเศษ __x เป็นจำนวนเต็มที่ใกล้ที่สุด แต่ปัดเศษกรณีครึ่งหนึ่งออกจากศูนย์ (แทนที่จะเป็นจำนวนเต็มคู่ที่ใกล้ที่สุด) ฟังก์ชันนี้คล้ายกับฟังก์ชัน round () แต่จะแตกต่างกันในประเภทของค่าที่ส่งคืนและสามารถเกิด overflow ได้ Returns ค่าจำนวนเต็มยาวที่ปัดเศษ ถ้า __x ไม่ใช่จำนวน จำกัด หรือโอเวอร์โฟลว์การรับรู้นี้จะส่งคืนค่า LONG_MIN (0x80000000)
28	double modf (double __x, double * __iptr ) ฟังก์ชัน modf () แบ่งอาร์กิวเมนต์ __x ออกเป็นส่วนอินทิกรัลและเศษส่วนซึ่งแต่ละส่วนมีเครื่องหมายเดียวกับอาร์กิวเมนต์ มันเก็บส่วนหนึ่งเป็นสองเท่าในวัตถุที่ชี้โดย __iptr ฟังก์ชัน modf () ส่งคืนส่วนที่เป็นเศษส่วนของ __x Note- การใช้งานนี้ข้ามการเขียนโดยตัวชี้ศูนย์ อย่างไรก็ตาม GCC 4.3 สามารถแทนที่ฟังก์ชันนี้ด้วยรหัสแบบอินไลน์ที่ไม่อนุญาตให้ใช้ที่อยู่ NULL เพื่อหลีกเลี่ยงการจัดเก็บ
29	float modff (float __x, float * __iptr) นามแฝงสำหรับ modf ()
30	double pow (double __x, double __y) ฟังก์ชัน pow () ส่งคืนค่า __x เป็นเลขชี้กำลัง __y
31	double round (double __x) ฟังก์ชัน round () จะปัดเศษ __x เป็นจำนวนเต็มที่ใกล้เคียงที่สุด แต่ปัดเศษกรณีครึ่งหนึ่งออกจากศูนย์ (แทนที่จะเป็นจำนวนเต็มคู่ที่ใกล้ที่สุด) ล้นเป็นไปไม่ได้ Returns ค่าที่ปัดเศษ ถ้า __x เป็นอินทิกรัลหรือไม่มีที่สิ้นสุด __x จะถูกส่งกลับ ถ้า __x คือNaNแล้ว NaN จะถูกส่งกลับ
32	int signbit (double __x) ฟังก์ชัน signbit () จะส่งคืนค่าที่ไม่ใช่ศูนย์หากค่า __x มีชุดบิตเครื่องหมาย สิ่งนี้ไม่เหมือนกับ `__x <0.0 'เนื่องจาก IEEE 754 floating point อนุญาตให้เซ็นชื่อเป็นศูนย์ การเปรียบเทียบ `-0.0 <0.0 'เป็นเท็จ แต่` `signbit (-0.0)' จะส่งกลับค่าที่ไม่ใช่ศูนย์
33	double sin (double __x) ฟังก์ชัน sin () จะคืนค่าไซน์ของ __x โดยวัดเป็นเรเดียน
34	double sinh (double __x) ฟังก์ชัน sinh () จะคืนค่าไฮเพอร์โบลิกไซน์ของ __x
35	double sqrt (double __x) ฟังก์ชัน sqrt () ส่งคืนค่ารากที่สองที่ไม่เป็นลบของ __x
36	double square (double __x) ฟังก์ชัน square () ส่งกลับ __x * __x Note - ฟังก์ชันนี้ไม่อยู่ในข้อกำหนดมาตรฐาน C
37	double tan (double __x) ฟังก์ชัน tan () ส่งคืนแทนเจนต์ของ __x ซึ่งวัดเป็นเรเดียน
38	double tanh ( double __x) ฟังก์ชัน tanh () จะคืนค่าไฮเพอร์โบลิกแทนเจนต์ของ __x
39	double trunc (double __x) ฟังก์ชัน trunc () จะปัดเศษ __x เป็นจำนวนเต็มที่ใกล้เคียงที่สุดโดยไม่เกินค่าสัมบูรณ์

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงวิธีการใช้ฟังก์ชันห้องสมุด math.h ที่พบบ่อยที่สุด -

double double__x = 45.45 ;
double double__y = 30.20 ;

void setup() {
   Serial.begin(9600);
   Serial.print("cos num = ");
   Serial.println (cos (double__x) ); // returns cosine of x
   Serial.print("absolute value of num = ");
   Serial.println (fabs (double__x) ); // absolute value of a float
   Serial.print("floating point modulo = ");
   Serial.println (fmod (double__x, double__y)); // floating point modulo
   Serial.print("sine of num = ");
   Serial.println (sin (double__x) ) ;// returns sine of x
   Serial.print("square root of num : ");
   Serial.println ( sqrt (double__x) );// returns square root of x
   Serial.print("tangent of num : ");
   Serial.println ( tan (double__x) ); // returns tangent of x
   Serial.print("exponential value of num : ");
   Serial.println ( exp (double__x) ); // function returns the exponential value of x.
   Serial.print("cos num : ");

   Serial.println (atan (double__x) ); // arc tangent of x
   Serial.print("tangent of num : ");
   Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x
   Serial.print("arc tangent of num : ");
   Serial.println (log (double__x) ) ; // natural logarithm of x
   Serial.print("cos num : ");
   Serial.println ( log10 (double__x)); // logarithm of x to base 10.
   Serial.print("logarithm of num to base 10 : ");
   Serial.println (pow (double__x, double__y) );// x to power of y
   Serial.print("power of num : ");
   Serial.println (square (double__x)); // square of x
}

void loop() {

}

ผลลัพธ์

cos num = 0.10
absolute value of num = 45.45
floating point modulo =15.25
sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf
cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf
power of num : 2065.70

คุณจำเป็นต้องใช้ตรีโกณมิติเช่นการคำนวณระยะทางสำหรับวัตถุเคลื่อนที่หรือความเร็วเชิงมุม Arduino มีฟังก์ชันตรีโกณมิติแบบดั้งเดิม (sin, cos, tan, asin, acos, atan) ซึ่งสามารถสรุปได้โดยการเขียนต้นแบบ Math.h มีต้นแบบของฟังก์ชันตรีโกณมิติ

ไวยากรณ์ที่แน่นอนของตรีโกณมิติ

double sin(double x); //returns sine of x radians
double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x
double asin(double x); //returns A, the angle corresponding to sin (A) = x
double atan(double x); //returns A, the angle corresponding to tan (A) = x

ตัวอย่าง

double sine = sin(2); // approximately 0.90929737091
double cosine = cos(2); // approximately -0.41614685058
double tangent = tan(2); // approximately -2.18503975868

Arduino Due เป็นบอร์ดไมโครคอนโทรลเลอร์ที่ใช้ CPU Atmel SAM3X8E ARM Cortex-M3 เป็นบอร์ด Arduino ตัวแรกที่ใช้ไมโครคอนโทรลเลอร์ ARM 32 บิต

คุณสมบัติที่สำคัญ -

• มีพินอินพุต / เอาต์พุตดิจิตอล 54 พิน (ซึ่ง 12 สามารถใช้เป็นเอาต์พุต PWM)
• อินพุตอะนาล็อก 12 ช่อง
• 4 UART (พอร์ตอนุกรมฮาร์ดแวร์)
• นาฬิกา 84 MHz การเชื่อมต่อที่รองรับ USB OTG
• 2 DAC (ดิจิตอลเป็นอนาล็อก), 2 TWI, แจ็คเพาเวอร์, ส่วนหัว SPI, ส่วนหัว JTAG
• ปุ่มรีเซ็ตและปุ่มลบ

ลักษณะของ Arduino Due Board

โวลต์ปฏิบัติการ	ความเร็วของ CPU	อนาล็อกเข้า / ออก	Digital IO / PWM	EEPROM [KB]	SRAM [KB]	แฟลช [KB]	ยูเอสบี	UART
3.3 โวลต์	84 เมกะเฮิร์ตซ์	12/2	54/12	-	96	512	2 ไมโคร	4

การสื่อสาร

• UART ฮาร์ดแวร์ 4 ตัว
• 2 I2C
• 1 CAN อินเทอร์เฟซ (โปรโตคอลสื่อสารยานยนต์)
• 1 SPI
• 1 อินเทอร์เฟซ JTAG (10 พิน)
• 1 โฮสต์ USB (เช่น Leonardo)
• 1 พอร์ตการเขียนโปรแกรม

ไม่เหมือนบอร์ด Arduino ส่วนใหญ่บอร์ด Arduino Due ทำงานที่ 3.3V แรงดันไฟฟ้าสูงสุดที่พิน I / O สามารถทนได้คือ 3.3V การใช้แรงดันไฟฟ้าที่สูงกว่า 3.3V กับพิน I / O ใด ๆ อาจทำให้บอร์ดเสียหายได้

บอร์ดประกอบด้วยทุกสิ่งที่จำเป็นในการรองรับไมโครคอนโทรลเลอร์ คุณสามารถเชื่อมต่อกับคอมพิวเตอร์ด้วยสายไมโคร USB หรือจ่ายไฟด้วยอะแดปเตอร์ AC-to-DC หรือแบตเตอรี่เพื่อเริ่มต้นใช้งาน เนื่องจากเข้ากันได้กับ Arduino shields ทั้งหมดที่ทำงานที่ 3.3V

Arduino Zero

Zero เป็นส่วนขยาย 32 บิตที่เรียบง่ายและมีประสิทธิภาพของแพลตฟอร์มที่ UNO ก่อตั้งขึ้น บอร์ด Zero ขยายตระกูลโดยการเพิ่มประสิทธิภาพการทำงานเปิดโอกาสในการทำโปรเจ็กต์ที่หลากหลายสำหรับอุปกรณ์และทำหน้าที่เป็นเครื่องมือทางการศึกษาที่ยอดเยี่ยมสำหรับการเรียนรู้เกี่ยวกับการพัฒนาแอพพลิเคชั่น 32 บิต

คุณสมบัติที่สำคัญคือ -

• แอปพลิเคชัน Zero ครอบคลุมตั้งแต่อุปกรณ์ IoT อัจฉริยะเทคโนโลยีที่สวมใส่ได้ระบบอัตโนมัติไฮเทคไปจนถึงหุ่นยนต์ที่บ้าคลั่ง

• บอร์ดนี้ใช้พลังงานจาก SAMD21 MCU ของ Atmel ซึ่งมีคอร์ ARM Cortex® M0 + 32 บิต

• หนึ่งในคุณสมบัติที่สำคัญที่สุดคือ Embedded Debugger (EDBG) ของ Atmel ซึ่งมีอินเทอร์เฟซการดีบักแบบเต็มโดยไม่ต้องใช้ฮาร์ดแวร์เพิ่มเติมซึ่งช่วยเพิ่มความสะดวกในการใช้งานสำหรับการดีบักซอฟต์แวร์

• EDBG ยังรองรับพอร์ต COM เสมือนที่สามารถใช้สำหรับอุปกรณ์และโปรแกรมโหลดบูต

ลักษณะของบอร์ด Arduino Zero

โวลต์ปฏิบัติการ	ความเร็วของ CPU	อนาล็อกเข้า / ออก	Digital IO / PWM	EEPROM [KB]	SRAM [KB]	แฟลช [KB]	ยูเอสบี	UART
3.3 โวลต์	48 เมกะเฮิร์ตซ์	6/1	14/10	-	32	256	2 ไมโคร	2

ไม่เหมือนกับบอร์ด Arduino และ Genuino ส่วนใหญ่ Zero จะทำงานที่ 3.3V แรงดันไฟฟ้าสูงสุดที่พิน I / O สามารถทนได้คือ 3.3V การใช้แรงดันไฟฟ้าที่สูงกว่า 3.3V กับพิน I / O ใด ๆ อาจทำให้บอร์ดเสียหายได้

บอร์ดประกอบด้วยทุกสิ่งที่จำเป็นในการรองรับไมโครคอนโทรลเลอร์ คุณสามารถเชื่อมต่อกับคอมพิวเตอร์ด้วยสายไมโคร USB หรือจ่ายไฟด้วยอะแดปเตอร์ AC-to-DC หรือแบตเตอรี่เพื่อเริ่มต้นใช้งาน Zero เข้ากันได้กับชิลด์ทั้งหมดที่ทำงานที่ 3.3V

Pulse Width Modulation หรือ PWM เป็นเทคนิคทั่วไปที่ใช้เพื่อเปลี่ยนความกว้างของพัลส์ในพัลส์ - เทรน PWM มีแอพพลิเคชั่นมากมายเช่นการควบคุมเซอร์โวและตัวควบคุมความเร็วซึ่ง จำกัด กำลังที่มีประสิทธิภาพของมอเตอร์และ LED

หลักการพื้นฐานของ PWM

โดยพื้นฐานแล้วการมอดูเลตความกว้างพัลส์คือคลื่นสี่เหลี่ยมที่มีเวลาสูงและต่ำแตกต่างกันไป สัญญาณ PWM พื้นฐานแสดงดังรูปต่อไปนี้

มีคำศัพท์ต่างๆที่เกี่ยวข้องกับ PWM -

• On-Time - ระยะเวลาของสัญญาณสูง

• Off-Time - ระยะเวลาของสัญญาณต่ำ

• Period - แสดงเป็นผลรวมของสัญญาณในเวลาและนอกเวลาของสัญญาณ PWM

• Duty Cycle - แสดงเป็นเปอร์เซ็นต์ของสัญญาณเวลาที่ยังคงเปิดอยู่ในช่วงระยะเวลาของสัญญาณ PWM

ระยะเวลา

ดังแสดงในรูป T _onหมายถึงการตรงเวลาและ T _offหมายถึงเวลานอกของสัญญาณ Period คือผลรวมของเวลาเปิดและปิดและคำนวณดังแสดงในสมการต่อไปนี้ -

รอบการทำงาน

รอบการทำงานคำนวณตามเวลาที่กำหนดในช่วงเวลาดังกล่าว เมื่อใช้ระยะเวลาที่คำนวณข้างต้นรอบการทำงานจะคำนวณเป็น -

analogWrite () ฟังก์ชัน

analogWrite()ฟังก์ชันเขียนค่าอนาล็อก (คลื่น PWM) ไปยังพิน สามารถใช้เพื่อจุดไฟ LED ที่ความสว่างต่างกันหรือขับมอเตอร์ด้วยความเร็วต่างๆ หลังจากการเรียกใช้ฟังก์ชัน analogWrite () พินจะสร้างคลื่นสี่เหลี่ยมคงที่ของรอบการทำงานที่ระบุจนกว่าจะมีการเรียกถัดไปที่ analogWrite () หรือการเรียกใช้ digitalRead () หรือ digitalWrite () บนพินเดียวกัน ความถี่ของสัญญาณ PWM บนพินส่วนใหญ่อยู่ที่ประมาณ 490 Hz บน Uno และบอร์ดที่คล้ายกันพิน 5 และ 6 มีความถี่ประมาณ 980 Hz Pins 3 และ 11 บน Leonardo ยังทำงานที่ 980 Hz

ในบอร์ด Arduino ส่วนใหญ่ (ที่มี ATmega168 หรือ ATmega328) ฟังก์ชันนี้จะทำงานบนพิน 3, 5, 6, 9, 10 และ 11 บน Arduino Mega จะทำงานบนพิน 2 - 13 และ 44 - 46 Arduino รุ่นเก่ากว่า บอร์ดที่รองรับ ATmega8 เท่านั้น analogWrite() บนหมุด 9, 10 และ 11

Arduino Due รองรับ analogWrite()บนหมุด 2 ถึง 13 และหมุด DAC0 และ DAC1 DAC0 และ DAC1 ต่างจากพิน PWM คือตัวแปลงดิจิตอลเป็นอนาล็อกและทำหน้าที่เป็นเอาต์พุตอนาล็อกที่แท้จริง

คุณไม่จำเป็นต้องเรียกใช้ pinMode () เพื่อตั้งค่าพินเป็นเอาต์พุตก่อนที่จะเรียก analogWrite ()

analogWrite () ไวยากรณ์ของฟังก์ชัน

analogWrite ( pin , value ) ;

value - รอบการทำงาน: ระหว่าง 0 (ปิดตลอดเวลา) และ 255 (เปิดตลอดเวลา)

Example

int ledPin = 9; // LED connected to digital pin 9
int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value

void setup() {
   pinMode(ledPin, OUTPUT); // sets the pin as output
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023, 
      // analogWrite values from 0 to 255
}

ในการสร้างตัวเลขสุ่มคุณสามารถใช้ฟังก์ชันตัวเลขสุ่ม Arduino เรามีสองฟังก์ชั่น -

• randomSeed(seed)
• random()

RandomSeed (เมล็ดพันธุ์)

ฟังก์ชัน randomSeed (seed) รีเซ็ตตัวสร้างหมายเลขหลอกของ Arduino แม้ว่าการแจกแจงของตัวเลขที่ส่งคืนโดย random () จะเป็นแบบสุ่ม แต่ลำดับก็สามารถคาดเดาได้ คุณควรรีเซ็ตเครื่องกำเนิดไฟฟ้าเป็นค่าสุ่ม หากคุณมีพินอนาล็อกที่ไม่ได้เชื่อมต่ออาจรับสัญญาณรบกวนแบบสุ่มจากสภาพแวดล้อมโดยรอบ สิ่งเหล่านี้อาจเป็นคลื่นวิทยุรังสีคอสมิกคลื่นแม่เหล็กไฟฟ้ารบกวนจากโทรศัพท์มือถือไฟเรืองแสงและอื่น ๆ

ตัวอย่าง

randomSeed(analogRead(5)); // randomize using noise from analog pin 5

สุ่ม ()

ฟังก์ชันสุ่มจะสร้างตัวเลขสุ่มหลอก ต่อไปนี้เป็นไวยากรณ์

สุ่ม () ไวยากรณ์คำสั่ง

long random(max) // it generate random numbers from 0 to max
long random(min, max) // it generate random numbers from min to max

ตัวอย่าง

long randNumber;

void setup() {
   Serial.begin(9600);
   // if analog input pin 0 is unconnected, random analog
   // noise will cause the call to randomSeed() to generate
   // different seed numbers each time the sketch runs.
   // randomSeed() will then shuffle the random function.
   randomSeed(analogRead(0));
}

void loop() {
   // print a random number from 0 to 299
   Serial.print("random1=");
   randNumber = random(300);
   Serial.println(randNumber); // print a random number from 0to 299
   Serial.print("random2=");
   randNumber = random(10, 20);// print a random number from 10 to 19
   Serial.println (randNumber);
   delay(50);
}

ตอนนี้ให้เรารีเฟรชความรู้ของเราเกี่ยวกับแนวคิดพื้นฐานบางอย่างเช่นบิตและไบต์

บิต

บิตเป็นเพียงเลขฐานสอง

• ระบบไบนารีใช้ตัวเลขสองหลัก 0 และ 1

• เช่นเดียวกับระบบเลขฐานสิบซึ่งตัวเลขของตัวเลขไม่มีค่าเดียวกัน 'นัยสำคัญ' ของบิตจะขึ้นอยู่กับตำแหน่งในเลขฐานสอง ตัวอย่างเช่นตัวเลขในเลขฐานสิบ 666 เหมือนกัน แต่มีค่าต่างกัน

ไบต์

ไบต์ประกอบด้วยแปดบิต

• ถ้าบิตเป็นตัวเลขก็เป็นตรรกะที่ไบต์แทนตัวเลข

• การดำเนินการทางคณิตศาสตร์ทั้งหมดสามารถทำได้

• ตัวเลขในไบต์ไม่มีนัยสำคัญเหมือนกัน

• บิตทางซ้ายสุดมีค่ามากที่สุดเรียกว่า Most Significant Bit (MSB)

• บิตด้านขวาสุดมีค่าน้อยที่สุดจึงเรียกว่า Least Significant Bit (LSB)

• เนื่องจากเลขศูนย์แปดตัวและหนึ่งไบต์สามารถรวมกันได้ 256 วิธีที่แตกต่างกันจำนวนทศนิยมที่ใหญ่ที่สุดที่สามารถแทนด้วยหนึ่งไบต์คือ 255 (ชุดค่าผสมหนึ่งชุดแทนค่าศูนย์)

การขัดจังหวะหยุดการทำงานปัจจุบันของ Arduino เพื่อให้สามารถทำงานอื่น ๆ ได้

สมมติว่าคุณกำลังนั่งอยู่ที่บ้านสนทนากับใครบางคน ทันใดนั้นโทรศัพท์ก็ดังขึ้น คุณหยุดสนทนาและรับโทรศัพท์เพื่อคุยกับผู้โทร เมื่อคุณสนทนาทางโทรศัพท์เสร็จแล้วคุณจะกลับไปสนทนากับบุคคลนั้นก่อนที่โทรศัพท์จะดังขึ้น

ในทำนองเดียวกันคุณอาจนึกถึงกิจวัตรหลักอย่างการแชทกับใครบางคนเสียงโทรศัพท์ทำให้คุณหยุดแชท ขั้นตอนการให้บริการขัดจังหวะคือขั้นตอนการพูดคุยทางโทรศัพท์ เมื่อการสนทนาทางโทรศัพท์สิ้นสุดลงคุณจะกลับไปที่กิจวัตรหลักในการสนทนา ตัวอย่างนี้อธิบายอย่างชัดเจนว่าการขัดจังหวะทำให้โปรเซสเซอร์ทำงานอย่างไร

โปรแกรมหลักกำลังทำงานและทำหน้าที่บางอย่างในวงจร อย่างไรก็ตามเมื่อเกิดการขัดจังหวะโปรแกรมหลักจะหยุดในขณะที่มีการดำเนินการตามขั้นตอนอื่น เมื่อกิจวัตรนี้เสร็จสิ้นโปรเซสเซอร์จะกลับไปที่รูทีนหลักอีกครั้ง

คุณสมบัติที่สำคัญ

คุณลักษณะสำคัญบางประการเกี่ยวกับการขัดจังหวะ -

• การขัดจังหวะอาจมาจากแหล่งต่างๆ ในกรณีนี้เรากำลังใช้การขัดจังหวะของฮาร์ดแวร์ที่เกิดจากการเปลี่ยนแปลงสถานะบนพินดิจิทัลตัวใดตัวหนึ่ง

• การออกแบบ Arduino ส่วนใหญ่มีการขัดจังหวะฮาร์ดแวร์สองตัว (เรียกว่า "interrupt0" และ "interrupt1") แบบต่อสายกับพิน I / O แบบดิจิทัล 2 และ 3 ตามลำดับ

• Arduino Mega มีการขัดจังหวะฮาร์ดแวร์หกตัวรวมถึงการขัดจังหวะเพิ่มเติม ("interrupt2" ถึง "interrupt5") บนพิน 21, 20, 19 และ 18

• คุณสามารถกำหนดรูทีนโดยใช้ฟังก์ชันพิเศษที่เรียกว่า“ Interrupt Service Routine” (โดยปกติเรียกว่า ISR)

• คุณสามารถกำหนดรูทีนและระบุเงื่อนไขที่ขอบขึ้นขอบตกหรือทั้งสองอย่าง ในเงื่อนไขเฉพาะเหล่านี้การขัดจังหวะจะได้รับการซ่อมบำรุง

• เป็นไปได้ที่จะให้ฟังก์ชันนั้นทำงานโดยอัตโนมัติทุกครั้งที่มีเหตุการณ์เกิดขึ้นที่ขาอินพุต

ประเภทของการขัดจังหวะ

การขัดจังหวะมีสองประเภท -

• Hardware Interrupts - เกิดขึ้นเพื่อตอบสนองต่อเหตุการณ์ภายนอกเช่นพินอินเทอร์รัปต์ภายนอกจะสูงหรือต่ำ

• Software Interrupts- เกิดขึ้นตามคำสั่งที่ส่งมาในซอฟต์แวร์ อินเตอร์รัปต์ประเภทเดียวที่“ ภาษา Arduino” รองรับคือฟังก์ชัน attachInterrupt ()

การใช้ Interrupts ใน Arduino

อินเทอร์รัปต์มีประโยชน์มากในโปรแกรม Arduino เนื่องจากช่วยในการแก้ปัญหาเรื่องเวลา การใช้อินเทอร์รัปต์ที่ดีคือการอ่านตัวเข้ารหัสแบบหมุนหรือสังเกตอินพุตของผู้ใช้ โดยทั่วไป ISR ควรสั้นและเร็วที่สุด หากร่างของคุณใช้ ISR หลายรายการสามารถรันได้ครั้งละหนึ่งรายการเท่านั้น การขัดจังหวะอื่น ๆ จะดำเนินการหลังจากการขัดจังหวะปัจจุบันเสร็จสิ้นตามลำดับที่ขึ้นอยู่กับลำดับความสำคัญที่มี

โดยทั่วไปแล้วตัวแปรส่วนกลางจะใช้เพื่อส่งผ่านข้อมูลระหว่าง ISR และโปรแกรมหลัก เพื่อให้แน่ใจว่าตัวแปรที่ใช้ร่วมกันระหว่าง ISR และโปรแกรมหลักได้รับการอัปเดตอย่างถูกต้องให้ประกาศว่าเป็นตัวแปรที่ผันผวน

attachInterrupt Statement Syntax

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

ค่าคงที่สามค่าต่อไปนี้ถูกกำหนดไว้ล่วงหน้าเป็นค่าที่ถูกต้อง -

• LOW เพื่อทริกเกอร์การขัดจังหวะเมื่อใดก็ตามที่พินอยู่ต่ำ

• CHANGE เพื่อทริกเกอร์การขัดจังหวะเมื่อใดก็ตามที่พินเปลี่ยนค่า

• FALLING เมื่อใดก็ตามที่พินจากสูงไปต่ำ

Example

int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}

มีการกำหนดโปรโตคอลการสื่อสารหลายร้อยรายการเพื่อให้เกิดการแลกเปลี่ยนข้อมูลนี้ แต่ละโปรโตคอลสามารถแบ่งออกเป็นหนึ่งในสองประเภท: ขนานหรืออนุกรม

การสื่อสารแบบขนาน

การเชื่อมต่อแบบขนานระหว่าง Arduino และอุปกรณ์ต่อพ่วงผ่านพอร์ตอินพุต / เอาต์พุตเป็นทางออกที่ดีสำหรับระยะทางสั้น ๆ ถึงหลายเมตร อย่างไรก็ตามในกรณีอื่น ๆ เมื่อจำเป็นต้องสร้างการสื่อสารระหว่างอุปกรณ์สองเครื่องในระยะทางที่ไกลขึ้นจะไม่สามารถใช้การเชื่อมต่อแบบขนานได้ อินเทอร์เฟซแบบขนานโอนหลายบิตในเวลาเดียวกัน พวกเขามักจะต้องใช้บัสของข้อมูล - ส่งผ่านสายแปด, สิบหกหรือมากกว่านั้น ข้อมูลจะถูกถ่ายโอนเป็นคลื่นขนาดใหญ่ที่พังทลายของ 1 และ 0

ข้อดีและข้อเสียของการสื่อสารแบบขนาน

การสื่อสารแบบขนานมีข้อดีอย่างแน่นอน เร็วกว่าแบบอนุกรมตรงไปตรงมาและใช้งานได้ค่อนข้างง่าย อย่างไรก็ตามต้องใช้พอร์ตและสายอินพุต / เอาต์พุต (I / O) จำนวนมาก หากคุณเคยต้องย้ายโปรเจ็กต์จาก Arduino Uno พื้นฐานไปยัง Mega คุณจะรู้ว่าสาย I / O บนไมโครโปรเซสเซอร์อาจมีค่าและมีน้อย ดังนั้นเราจึงชอบการสื่อสารแบบอนุกรมโดยเสียสละความเร็วที่เป็นไปได้สำหรับอสังหาริมทรัพย์แบบพิน

โมดูลการสื่อสารแบบอนุกรม

ทุกวันนี้บอร์ด Arduino ส่วนใหญ่สร้างขึ้นด้วยระบบต่างๆสำหรับการสื่อสารแบบอนุกรมเป็นอุปกรณ์มาตรฐาน

ระบบใดที่ใช้ขึ้นอยู่กับปัจจัยต่อไปนี้ -

• ไมโครคอนโทรลเลอร์ต้องแลกเปลี่ยนข้อมูลกับอุปกรณ์กี่เครื่อง?
• การแลกเปลี่ยนข้อมูลต้องเร็วแค่ไหน?
• ระยะห่างระหว่างอุปกรณ์เหล่านี้คืออะไร?
• จำเป็นต้องส่งและรับข้อมูลพร้อมกันหรือไม่?

สิ่งที่สำคัญที่สุดอย่างหนึ่งเกี่ยวกับการสื่อสารแบบอนุกรมคือ Protocolซึ่งควรปฏิบัติอย่างเคร่งครัด เป็นชุดของกฎซึ่งต้องใช้เพื่อให้อุปกรณ์สามารถตีความข้อมูลที่แลกเปลี่ยนกันได้อย่างถูกต้อง โชคดีที่ Arduino ดูแลเรื่องนี้โดยอัตโนมัติเพื่อให้งานของโปรแกรมเมอร์ / ผู้ใช้ลดลงเป็นการเขียนอย่างง่าย (ข้อมูลที่จะส่ง) และอ่าน (ข้อมูลที่ได้รับ)

ประเภทของการสื่อสารแบบอนุกรม

การสื่อสารแบบอนุกรมสามารถจำแนกได้อีกเป็น -

• Synchronous - อุปกรณ์ที่ซิงโครไนซ์ใช้นาฬิกาเดียวกันและเวลาอยู่ในการซิงโครไนซ์ซึ่งกันและกัน

• Asynchronous - อุปกรณ์ที่เป็นแบบอะซิงโครนัสมีนาฬิกาของตัวเองและถูกกระตุ้นโดยเอาต์พุตของสถานะก่อนหน้า

ง่ายต่อการตรวจสอบว่าอุปกรณ์ซิงโครนัสหรือไม่ หากนาฬิกาเดียวกันถูกกำหนดให้กับอุปกรณ์ที่เชื่อมต่อทั้งหมดแสดงว่าเป็นแบบซิงโครนัส หากไม่มีเส้นนาฬิกาแสดงว่าเป็นแบบอะซิงโครนัส

ตัวอย่างเช่นโมดูล UART (Universal Asynchronous Receiver Transmitter) เป็นแบบอะซิงโครนัส

โปรโตคอลอนุกรมแบบอะซิงโครนัสมีกฎในตัวจำนวนหนึ่ง กฎเหล่านี้ไม่ใช่เพียงกลไกที่ช่วยให้แน่ใจว่าการถ่ายโอนข้อมูลมีประสิทธิภาพและปราศจากข้อผิดพลาด กลไกเหล่านี้ที่เราได้รับจากการละเว้นสัญญาณนาฬิกาภายนอกคือ -

• บิตการซิงโครไนซ์
• บิตข้อมูล
• พาริตีบิต
• อัตราบอด

การซิงโครไนซ์บิต

บิตการซิงโครไนซ์คือบิตพิเศษสองหรือสามบิตที่ถ่ายโอนไปกับแต่ละแพ็กเก็ตของข้อมูล เป็นบิตเริ่มต้นและบิตหยุด เป็นชื่อจริงบิตเหล่านี้ทำเครื่องหมายจุดเริ่มต้นและจุดสิ้นสุดของแพ็กเก็ตตามลำดับ

มีบิตเริ่มต้นเพียงบิตเดียวเสมอ แต่สามารถกำหนดจำนวนบิตหยุดเป็นหนึ่งหรือสองได้ (แม้ว่าโดยปกติจะเหลือไว้ที่หนึ่ง)

บิตเริ่มต้นจะถูกระบุด้วยสายข้อมูลที่ไม่ได้ใช้งานโดยเริ่มจาก 1 ถึง 0 เสมอในขณะที่บิตหยุดจะเปลี่ยนกลับไปเป็นสถานะว่างโดยถือบรรทัดที่ 1

บิตข้อมูล

จำนวนข้อมูลในแต่ละแพ็กเก็ตสามารถกำหนดขนาดใดก็ได้ตั้งแต่ 5 ถึง 9 บิต แน่นอนว่าขนาดข้อมูลมาตรฐานคือไบต์ 8 บิตพื้นฐานของคุณ แต่ขนาดอื่น ๆ ก็มีประโยชน์ แพ็กเก็ตข้อมูล 7 บิตสามารถมีประสิทธิภาพมากกว่า 8 โดยเฉพาะอย่างยิ่งหากคุณกำลังถ่ายโอนอักขระ ASCII 7 บิต

Parity Bits

ผู้ใช้สามารถเลือกได้ว่าควรจะมีพาริตีบิตหรือไม่และถ้าใช่พาริตีควรเป็นคี่หรือคู่ พาริตีบิตเป็น 0 ถ้าจำนวน 1 ในบิตข้อมูลเท่ากัน ความเท่าเทียมกันเป็นสิ่งที่ตรงกันข้าม

อัตราบอด

คำว่าอัตราการส่งข้อมูลใช้เพื่อแสดงจำนวนบิตที่ถ่ายโอนต่อวินาที [bps] โปรดทราบว่าหมายถึงบิตไม่ใช่ไบต์ โดยปกติโปรโตคอลจะกำหนดให้แต่ละไบต์ถูกโอนไปพร้อมกับบิตควบคุมหลายตัว หมายความว่าหนึ่งไบต์ในสตรีมข้อมูลอนุกรมอาจประกอบด้วย 11 บิต ตัวอย่างเช่นหากอัตราการส่งข้อมูลคือ 300 bps ระบบอาจโอนสูงสุด 37 และต่ำสุด 27 ไบต์ต่อวินาที

Arduino UART

รหัสต่อไปนี้จะทำให้ Arduino ส่งสวัสดีชาวโลกได้เมื่อเริ่มทำงาน

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
   Serial.println("hello world"); //print hello world
}

void loop() {

}

หลังจากอัปโหลดร่าง Arduino ไปยัง Arduino แล้วให้เปิด Serial monitor

ที่ส่วนขวาบนของ Arduino IDE

พิมพ์อะไรก็ได้ในช่องด้านบนของ Serial Monitor แล้วกดส่งหรือป้อนบนแป้นพิมพ์ สิ่งนี้จะส่งชุดไบต์ไปยัง Arduino

รหัสต่อไปนี้จะส่งคืนสิ่งที่ได้รับเป็นอินพุต

รหัสต่อไปนี้จะทำให้ Arduino ส่งเอาต์พุตขึ้นอยู่กับอินพุตที่ให้มา

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
}

void loop() {
   if(Serial.available()) //if number of bytes (characters) available for reading from { 
      serial port
      Serial.print("I received:"); //print I received
      Serial.write(Serial.read()); //send what you read
   }
}

สังเกตว่า Serial.print และ Serial.println จะส่งคืนรหัส ASCII จริงในขณะที่ Serial.writeจะส่งข้อความจริงกลับไป ดูรหัส ASCII สำหรับข้อมูลเพิ่มเติม

Inter-integrated circuit (I2C) เป็นระบบสำหรับการแลกเปลี่ยนข้อมูลแบบอนุกรมระหว่างไมโครคอนโทรลเลอร์และวงจรรวมเฉพาะของคนรุ่นใหม่ ใช้เมื่อระยะห่างระหว่างกันสั้น (ตัวรับและตัวส่งมักจะอยู่บนบอร์ดพิมพ์เดียวกัน) การเชื่อมต่อถูกสร้างขึ้นผ่านตัวนำสองตัว หนึ่งใช้สำหรับการถ่ายโอนข้อมูลและอีกอันใช้สำหรับซิงโครไนซ์ (สัญญาณนาฬิกา)

ดังที่เห็นในรูปต่อไปนี้อุปกรณ์ชิ้นหนึ่งมักจะเป็นหลัก ดำเนินการระบุที่อยู่ของชิปทาสหนึ่งตัวก่อนที่การสื่อสารจะเริ่มต้น ด้วยวิธีนี้ไมโครคอนโทรลเลอร์หนึ่งตัวสามารถสื่อสารกับอุปกรณ์ต่างๆได้ 112 เครื่อง โดยปกติอัตราบอดคือ 100 Kb / วินาที (โหมดมาตรฐาน) หรือ 10 Kb / วินาที (โหมดอัตราบอดช้า) ระบบที่มีอัตราการส่งข้อมูล 3.4 Mb / วินาทีเพิ่งปรากฏขึ้น ระยะห่างระหว่างอุปกรณ์ที่สื่อสารผ่านบัส I2C ถูก จำกัด ไว้ที่หลายเมตร

พินบอร์ด I2C

บัส I2C ประกอบด้วยสองสัญญาณ - SCL และ SDA SCL คือสัญญาณนาฬิกาและ SDA คือสัญญาณข้อมูล บัสมาสเตอร์ปัจจุบันสร้างสัญญาณนาฬิกาเสมอ อุปกรณ์สเลฟบางตัวอาจบังคับให้นาฬิกาต่ำในบางครั้งเพื่อหน่วงเวลาที่มาสเตอร์จะส่งข้อมูลมากขึ้น (หรือต้องการเวลาในการเตรียมข้อมูลมากขึ้นก่อนที่มาสเตอร์จะพยายามจับเวลา) ซึ่งเรียกว่า "นาฬิกายืด"

ต่อไปนี้เป็นหมุดสำหรับบอร์ด Arduino ต่างๆ -

• Uno, Pro Mini A4 (SDA), A5 (SCL)
• เมกะ, ครบกำหนด20 (SDA), 21 (SCL)
• ลีโอนาร์โด, หยุน2 (SDA), 3 (SCL)

Arduino I2C

เรามีสองโหมด - รหัสหลักและรหัสทาส - เพื่อเชื่อมต่อบอร์ด Arduino สองตัวโดยใช้ I2C พวกเขาคือ -

• เครื่องส่งสัญญาณหลัก / ตัวรับทาส
• ตัวรับสัญญาณหลัก / เครื่องส่งสัญญาณทาส

เครื่องส่งสัญญาณหลัก / ตัวรับทาส

ตอนนี้ให้เราดูว่าตัวส่งสัญญาณหลักและตัวรับสัญญาณทาสคืออะไร

เครื่องส่งสัญญาณหลัก

ฟังก์ชันต่อไปนี้ใช้เพื่อเริ่มต้นไลบรารี Wire และเข้าร่วมบัส I2C เป็นมาสเตอร์หรือทาส โดยปกติจะเรียกเพียงครั้งเดียว

• Wire.begin(address) - แอดเดรสคือที่อยู่สเลฟ 7 บิตในกรณีของเราเนื่องจากไม่ได้ระบุมาสเตอร์และจะเข้าร่วมบัสในฐานะมาสเตอร์

• Wire.beginTransmission(address) - เริ่มต้นการส่งไปยังอุปกรณ์ทาส I2C ด้วยที่อยู่ที่กำหนด

• Wire.write(value) - คิวไบต์สำหรับการส่งจากอุปกรณ์ต้นแบบไปยังอุปกรณ์ทาส (ระหว่างการโทรไปยัง beginTransmission () และ endTransmission ())

• Wire.endTransmission() - สิ้นสุดการส่งไปยังอุปกรณ์ทาสที่เริ่มต้นโดย startTransmission () และส่งไบต์ที่จัดคิวโดย wire.write ()

Example

#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}

ผู้รับทาส

ใช้ฟังก์ชันต่อไปนี้ -

• Wire.begin(address) - ที่อยู่คือที่อยู่ทาส 7 บิต

• Wire.onReceive(received data handler) - ฟังก์ชั่นที่จะเรียกใช้เมื่ออุปกรณ์ทาสได้รับข้อมูลจากต้นแบบ

• Wire.available() - ส่งคืนจำนวนไบต์ที่พร้อมใช้งานสำหรับการดึงข้อมูลด้วย Wire.read () ซึ่งควรถูกเรียกภายในตัวจัดการ Wire.onReceive ()

Example

#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}

ตัวรับสัญญาณหลัก / เครื่องส่งสัญญาณทาส

ตอนนี้ให้เราดูว่าตัวรับสัญญาณหลักและเครื่องส่งสัญญาณทาสคืออะไร

ผู้รับปริญญาโท

Master ได้รับการตั้งโปรแกรมให้ร้องขอและอ่านไบต์ของข้อมูลที่ส่งมาจาก Slave Arduino ที่ไม่ซ้ำกัน

ใช้ฟังก์ชันต่อไปนี้ -

Wire.requestFrom(address,number of bytes)- ใช้โดยต้นแบบเพื่อขอไบต์จากอุปกรณ์ทาส จากนั้นไบต์อาจถูกดึงมาด้วยฟังก์ชัน wire.available () และ wire.read ()

Example

#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}

เครื่องส่งสัญญาณทาส

ใช้ฟังก์ชันต่อไปนี้

Wire.onRequest(handler) - ฟังก์ชันถูกเรียกใช้เมื่อมาสเตอร์ร้องขอข้อมูลจากอุปกรณ์ทาสนี้

Example

#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}

บัส Serial Peripheral Interface (SPI) เป็นระบบสำหรับการสื่อสารแบบอนุกรมซึ่งใช้ตัวนำมากถึงสี่ตัวโดยทั่วไปคือสามตัว ตัวนำหนึ่งใช้สำหรับการรับข้อมูลหนึ่งสำหรับการส่งข้อมูลหนึ่งสำหรับการซิงโครไนซ์และอีกทางเลือกหนึ่งสำหรับการเลือกอุปกรณ์ที่จะสื่อสารด้วย เป็นการเชื่อมต่อแบบดูเพล็กซ์เต็มรูปแบบซึ่งหมายความว่ามีการส่งและรับข้อมูลพร้อมกัน อัตราการส่งข้อมูลสูงสุดสูงกว่าในระบบสื่อสาร I2C

หมุด SPI ของบอร์ด

SPI ใช้สี่สายต่อไปนี้ -

• SCK - นี่คือนาฬิกาแบบอนุกรมที่ขับเคลื่อนโดยต้นแบบ

• MOSI - นี่คืออินพุตเอาต์พุตหลัก / ทาสที่ขับเคลื่อนโดยมาสเตอร์

• MISO - นี่คือเอาต์พุตอินพุต / ทาสหลักที่ขับเคลื่อนโดยมาสเตอร์

• SS - นี่คือสายการเลือกทาส

ใช้ฟังก์ชันต่อไปนี้ คุณต้องรวม SPI.h.

• SPI.begin() - เริ่มต้นบัส SPI โดยการตั้งค่า SCK, MOSI และ SS เป็นเอาต์พุตดึง SCK และ MOSI ให้ต่ำและ SS สูง

• SPI.setClockDivider(divider)- เพื่อตั้งค่าตัวแบ่งนาฬิกา SPI ที่สัมพันธ์กับนาฬิการะบบ บนบอร์ดที่ใช้ AVR ตัวแบ่งที่มีคือ 2, 4, 8, 16, 32, 64 หรือ 128 การตั้งค่าเริ่มต้นคือ SPI_CLOCK_DIV4 ซึ่งตั้งค่านาฬิกา SPI เป็นหนึ่งในสี่ของความถี่ของนาฬิการะบบ (5 Mhz สำหรับ บอร์ดที่ 20 MHz)

• Divider - อาจเป็น (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128)

• SPI.transfer(val) - การถ่ายโอน SPI ขึ้นอยู่กับการส่งและรับพร้อมกัน: ข้อมูลที่ได้รับจะถูกส่งคืนใน receivedVal

• SPI.beginTransaction(SPISettings(speedMaximum, dataOrder, dataMode)) - speedMaximum คือนาฬิกา dataOrder (MSBFIRST หรือ LSBFIRST) dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2 หรือ SPI_MODE3)

เรามีโหมดการทำงานสี่โหมดใน SPI ดังนี้ -

• Mode 0 (the default) - นาฬิกาปกติจะต่ำ (CPOL = 0) และข้อมูลจะถูกสุ่มตัวอย่างจากการเปลี่ยนจากต่ำไปสูง (ขอบนำ) (CPHA = 0)

• Mode 1 - นาฬิกาปกติจะต่ำ (CPOL = 0) และข้อมูลจะถูกสุ่มตัวอย่างจากการเปลี่ยนจากสูงไปต่ำ (ขอบด้านหลัง) (CPHA = 1)

• Mode 2 - นาฬิกาปกติจะสูง (CPOL = 1) และข้อมูลจะถูกสุ่มตัวอย่างในการเปลี่ยนจากสูงไปต่ำ (ขอบนำ) (CPHA = 0)

• Mode 3 - นาฬิกาปกติจะสูง (CPOL = 1) และข้อมูลจะถูกสุ่มตัวอย่างจากการเปลี่ยนจากต่ำไปสูง (ขอบด้านหลัง) (CPHA = 1)

• SPI.attachInterrupt(handler) - ฟังก์ชั่นที่จะเรียกใช้เมื่ออุปกรณ์ทาสได้รับข้อมูลจากต้นแบบ

ตอนนี้เราจะเชื่อมต่อบอร์ด Arduino UNO สองตัวเข้าด้วยกัน คนหนึ่งเป็นนายและอีกคนเป็นทาส

• (SS): พิน 10
• (MOSI): พิน 11
• (MISO): พิน 12
• (SCK): พิน 13

พื้นดินเป็นเรื่องธรรมดา ต่อไปนี้คือการแสดงแผนภาพของการเชื่อมต่อระหว่างบอร์ดทั้งสอง -

ให้เราดูตัวอย่างของ SPI เป็น Master และ SPI เป็น Slave

SPI เป็น MASTER

ตัวอย่าง

#include <SPI.h>

void setup (void) {
   Serial.begin(115200); //set baud rate to 115200 for usart
   digitalWrite(SS, HIGH); // disable Slave Select
   SPI.begin ();
   SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
}

void loop (void) {
   char c;
   digitalWrite(SS, LOW); // enable Slave Select
   // send test string
   for (const char * p = "Hello, world!\r" ; c = *p; p++) {
      SPI.transfer (c);
      Serial.print(c);
   }
   digitalWrite(SS, HIGH); // disable Slave Select
   delay(2000);
}

SPI เป็นทาส

ตัวอย่าง

#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {
   Serial.begin (115200);
   pinMode(MISO, OUTPUT); // have to send on master in so it set as output
   SPCR |= _BV(SPE); // turn on SPI in slave mode
   indx = 0; // buffer empty
   process = false;
   SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) // SPI interrupt routine { 
   byte c = SPDR; // read byte from SPI Data Register
   if (indx < sizeof buff) {
      buff [indx++] = c; // save data in the next index in the array buff
      if (c == '\r') //check for the end of the word
      process = true;
   }
}

void loop (void) {
   if (process) {
      process = false; //reset the process
      Serial.println (buff); //print the array on serial monitor
      indx= 0; //reset button to zero
   }
}

LED เป็นไฟขนาดเล็กที่ทรงพลังซึ่งใช้ในงานต่างๆมากมาย ในการเริ่มต้นเราจะทำงานเกี่ยวกับการกะพริบ LED Hello World ของไมโครคอนโทรลเลอร์ ทำได้ง่ายเพียงแค่เปิดและปิดไฟ การสร้างพื้นฐานที่สำคัญนี้จะทำให้คุณมีรากฐานที่มั่นคงในขณะที่เราดำเนินการทดลองที่มีความซับซ้อนมากขึ้น

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• 1 × LED
• ตัวต้านทาน 1 ×330Ω
• 2 ×จัมเปอร์

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

Note- หากต้องการทราบขั้วของ LED ให้ดูอย่างใกล้ชิด ยิ่งขาสองข้างสั้นลงไปทางขอบแบนของหลอดไฟแสดงถึงขั้วลบ

ส่วนประกอบเช่นตัวต้านทานจำเป็นต้องให้ขั้วของพวกเขางอเป็นมุม 90 °เพื่อให้พอดีกับซ็อกเก็ตเขียงหั่นขนมอย่างถูกต้อง คุณยังสามารถตัดขั้วให้สั้นลงได้

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

/*
   Blink
   Turns on an LED on for one second, then off for one second, repeatedly.
*/

// the setup function runs once when you press reset or power the board

void setup() {  // initialize digital pin 13 as an output.
   pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
   digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
   delay(1000); // wait for a second
   digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
   delay(1000); // wait for a second
}

รหัสที่ควรทราบ

pinMode(2, OUTPUT)- ก่อนจะใช้พินของ Arduino ได้คุณต้องบอก Arduino Uno R3 ว่าเป็น INPUT หรือ OUTPUT เราใช้“ ฟังก์ชัน” ในตัวที่เรียกว่า pinMode () เพื่อทำสิ่งนี้

digitalWrite(2, HIGH) - เมื่อคุณใช้พินเป็น OUTPUT คุณสามารถสั่งให้เป็น HIGH (เอาต์พุต 5 โวลต์) หรือ LOW (เอาต์พุต 0 โวลต์)

ผลลัพธ์

คุณควรเห็น LED ของคุณเปิดและปิด หากไม่เห็นเอาต์พุตที่ต้องการตรวจสอบให้แน่ใจว่าคุณประกอบวงจรอย่างถูกต้องและตรวจสอบและอัปโหลดรหัสไปยังบอร์ดของคุณ

ตัวอย่างนี้แสดงให้เห็นถึงการใช้ฟังก์ชัน analogWrite () ในการทำให้ LED ดับลง AnalogWrite ใช้การมอดูเลตความกว้างพัลส์ (PWM) เปิดและปิดพินดิจิทัลอย่างรวดเร็วด้วยอัตราส่วนที่แตกต่างกันระหว่างเปิดและปิดเพื่อสร้างเอฟเฟกต์การซีดจาง

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• 1 × LED
• ตัวต้านทาน 1 ×330Ω
• 2 ×จัมเปอร์

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

Note- หากต้องการทราบขั้วของ LED ให้ดูอย่างใกล้ชิด ยิ่งขาสองข้างสั้นลงไปทางขอบแบนของหลอดไฟแสดงถึงขั้วลบ

ส่วนประกอบเช่นตัวต้านทานจำเป็นต้องให้ขั้วของพวกเขางอเป็นมุม 90 °เพื่อให้พอดีกับซ็อกเก็ตเขียงหั่นขนมอย่างถูกต้อง คุณยังสามารถตัดขั้วให้สั้นลงได้

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

/*
   Fade
   This example shows how to fade an LED on pin 9 using the analogWrite() function.

   The analogWrite() function uses PWM, so if you want to change the pin you're using, be
   sure to use another PWM capable pin. On most Arduino, the PWM pins are identified with
   a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
*/

int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
// the setup routine runs once when you press reset:

void setup() {
   // declare pin 9 to be an output:
   pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop() {
   // set the brightness of pin 9:
   analogWrite(led, brightness);
   // change the brightness for next time through the loop:
   brightness = brightness + fadeAmount;
   // reverse the direction of the fading at the ends of the fade:
   if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ;
   }
   // wait for 30 milliseconds to see the dimming effect
   delay(300);
}

รหัสที่ควรทราบ

หลังจากประกาศพิน 9 เป็นพิน LED ของคุณไม่มีอะไรต้องทำในฟังก์ชันการตั้งค่า () ของรหัสของคุณ ฟังก์ชัน analogWrite () ที่คุณจะใช้ในลูปหลักของโค้ดของคุณต้องใช้อาร์กิวเมนต์สองตัว: ตัวหนึ่งบอกฟังก์ชันที่จะเขียนพินและอีกตัวระบุว่าจะเขียนค่า PWM ใด

ในการทำให้ LED ปิดและเปิดจางลงค่อยๆเพิ่มค่า PWM จาก 0 (ตลอดทาง) เป็น 255 (เปิดตลอดทาง) จากนั้นกลับไปที่ 0 เพื่อให้ครบวงจร ในภาพร่างที่ให้ไว้ข้างต้นค่า PWM ถูกตั้งค่าโดยใช้ตัวแปรที่เรียกว่าความสว่าง ทุกครั้งที่ผ่านลูปจะเพิ่มขึ้นตามค่าของตัวแปรfadeAmount.

หากความสว่างอยู่ที่ค่ามากเกินไป (0 หรือ 255) ก็จะเปลี่ยน fadeAmount เป็นค่าลบ กล่าวอีกนัยหนึ่งคือถ้า fadeAmount เป็น 5 ก็จะตั้งค่าเป็น -5 ถ้าเป็น -5 ก็จะตั้งค่าเป็น 5 ในครั้งต่อไปผ่านลูปการเปลี่ยนแปลงนี้จะทำให้ความสว่างเปลี่ยนทิศทางเช่นกัน

analogWrite()สามารถเปลี่ยนค่า PWM ได้เร็วมากดังนั้นการหน่วงเวลาในตอนท้ายของร่างจะควบคุมความเร็วของการจาง ลองเปลี่ยนค่าของการหน่วงเวลาและดูว่าจะเปลี่ยนเอฟเฟกต์การซีดจางอย่างไร

ผลลัพธ์

คุณควรเห็นความสว่าง LED ของคุณค่อยๆเปลี่ยนไป

ตัวอย่างนี้จะแสดงวิธีการอ่านอินพุตอนาล็อกบนพินอนาล็อก 0 อินพุตถูกแปลงจาก analogRead () เป็นแรงดันไฟฟ้าและพิมพ์ออกไปยังจอภาพอนุกรมของซอฟต์แวร์ Arduino (IDE)

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• ตัวต้านทานตัวแปร 1 × 5K (โพเทนชิออมิเตอร์)
• 2 ×จัมเปอร์

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

โพเทนชิออมิเตอร์

โพเทนชิออมิเตอร์ (หรือหม้อ) เป็นตัวแปลงสัญญาณไฟฟ้าเชิงกลอย่างง่าย มันแปลงการเคลื่อนที่แบบหมุนหรือเชิงเส้นจากตัวดำเนินการอินพุตเป็นการเปลี่ยนแปลงความต้านทาน การเปลี่ยนแปลงนี้คือ (หรือสามารถใช้) เพื่อควบคุมอะไรก็ได้ตั้งแต่ปริมาณของระบบไฮไฟไปจนถึงทิศทางของเรือคอนเทนเนอร์ขนาดใหญ่

หม้อที่เรารู้จักกัน แต่เดิมเรียกว่า rheostat (โดยพื้นฐานแล้วเป็นตัวต้านทานแบบลวดพันตัวแปร) ความหลากหลายของหม้อที่มีอยู่ในตอนนี้ค่อนข้างน่าประหลาดใจและอาจเป็นเรื่องยากสำหรับผู้เริ่มต้น (โดยเฉพาะ) ในการพิจารณาว่าประเภทใดเหมาะกับงานที่กำหนด หม้อที่แตกต่างกันสองสามประเภทซึ่งสามารถใช้สำหรับงานเดียวกันทำให้งานยากขึ้น

ภาพด้านซ้ายแสดงสัญลักษณ์แผนผังมาตรฐานของหม้อ ภาพด้านขวาคือโพเทนชิออมิเตอร์

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

/*
   ReadAnalogVoltage
   Reads an analog input on pin 0, converts it to voltage, 
   and prints the result to the serial monitor.
   Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
   Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
*/

// the setup routine runs once when you press reset:

void setup() {
   // initialize serial communication at 9600 bits per second:
   Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
   // read the input on analog pin 0:
   int sensorValue = analogRead(A0);
   // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
   float voltage = sensorValue * (5.0 / 1023.0);
   // print out the value you read:
   Serial.println(voltage);
}

รหัสที่ควรทราบ

ในโปรแกรมหรือร่างที่ระบุด้านล่างสิ่งแรกที่คุณทำในฟังก์ชั่นการตั้งค่าคือเริ่มการสื่อสารแบบอนุกรมที่ 9600 บิตต่อวินาทีระหว่างบอร์ดและคอมพิวเตอร์ของคุณด้วยสาย -

Serial.begin(9600);

ในลูปหลักของรหัสของคุณคุณต้องสร้างตัวแปรเพื่อเก็บค่าความต้านทาน (ซึ่งจะอยู่ระหว่าง 0 ถึง 1023 เหมาะสำหรับประเภทข้อมูล int) ที่มาจากโพเทนชิออมิเตอร์ของคุณ -

int sensorValue = analogRead(A0);

หากต้องการเปลี่ยนค่าจาก 0-1023 เป็นช่วงที่สอดคล้องกับแรงดันไฟฟ้าพินกำลังอ่านคุณต้องสร้างตัวแปรอื่นลูกลอยและทำการคำนวณเล็กน้อย ในการปรับขนาดตัวเลขระหว่าง 0.0 ถึง 5.0 ให้หาร 5.0 ด้วย 1023.0 และคูณด้วย sensorValue -

float voltage= sensorValue * (5.0 / 1023.0);

สุดท้ายคุณต้องพิมพ์ข้อมูลนี้ไปยังหน้าต่างซีเรียลของคุณ คุณสามารถทำได้ด้วยคำสั่ง Serial.println () ในบรรทัดสุดท้ายของโค้ด -

Serial.println(voltage)

ตอนนี้เปิด Serial Monitor ใน Arduino IDE โดยคลิกไอคอนทางด้านขวาของแถบสีเขียวด้านบนหรือกด Ctrl + Shift + M

ผลลัพธ์

คุณจะเห็นตัวเลขที่สม่ำเสมอตั้งแต่ 0.0 - 5.0 เมื่อคุณหมุนหม้อค่าต่างๆจะเปลี่ยนไปตามแรงดันไฟฟ้าที่ขา A0

ตัวอย่างนี้แสดงวิธีการอ่านอินพุตอะนาล็อกที่พินอนาล็อก 0 แปลงค่าจาก analogRead () เป็นแรงดันไฟฟ้าและพิมพ์ออกไปยังจอภาพแบบอนุกรมของซอฟต์แวร์ Arduino (IDE)

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• ตัวต้านทานตัวแปร 1 × 5k โอห์ม (โพเทนชิออมิเตอร์)
• 2 ×จัมเปอร์
• 8 × LED หรือคุณสามารถใช้ (แสดงกราฟแท่ง LED ตามที่แสดงในภาพด้านล่าง)

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

กราฟแท่ง LED 10 ส่วน

LED กราฟแท่ง 10 เซกเมนต์เหล่านี้มีประโยชน์มากมาย ด้วยขนาดที่กะทัดรัดการเชื่อมต่อที่เรียบง่ายจึงเป็นเรื่องง่ายสำหรับผลิตภัณฑ์ต้นแบบหรือผลิตภัณฑ์สำเร็จรูป โดยพื้นฐานแล้วพวกเขาคือ LED สีน้ำเงิน 10 ดวงที่อยู่ด้วยกันแต่ละดวงมีการเชื่อมต่อขั้วบวกและขั้วลบ

นอกจากนี้ยังมีสีเหลืองสีแดงและสีเขียว

Note- หมุดบนกราฟแท่งเหล่านี้อาจแตกต่างจากที่ระบุไว้ในแผ่นข้อมูล การหมุนอุปกรณ์ 180 องศาจะแก้ไขการเปลี่ยนแปลงทำให้พิน 11 เป็นพินแรกในบรรทัด

รหัส Arduino

/*
   LED bar graph
   Turns on a series of LEDs based on the value of an analog sensor. 
   This is a simple way to make a bar graph display. 
   Though this graph uses 8LEDs, you can use any number by
      changing the LED count and the pins in the array.
   This method can be used to control any series of digital
      outputs that depends on an analog input.
*/

// these constants won't change:
const int analogPin = A0; // the pin that the potentiometer is attached to
const int ledCount = 8; // the number of LEDs in the bar graph
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an array of pin numbers to which LEDs are attached

void setup() {
   // loop over the pin array and set them all to output:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      pinMode(ledPins[thisLed], OUTPUT);
   }
}

void loop() {
   // read the potentiometer:
   int sensorReading = analogRead(analogPin);
   // map the result to a range from 0 to the number of LEDs:
   int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
   // loop over the LED array:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      // if the array element's index is less than ledLevel,
      // turn the pin for this element on:
      if (thisLed < ledLevel) {
         digitalWrite(ledPins[thisLed], HIGH);
      }else { // turn off all pins higher than the ledLevel:
         digitalWrite(ledPins[thisLed], LOW);
      }
   }
}

รหัสที่ควรทราบ

ร่างจะทำงานในลักษณะนี้ก่อนอื่นคุณอ่านอินพุต คุณจับคู่ค่าอินพุตกับช่วงเอาต์พุตในกรณีนี้ไฟ LED 10 ดวง จากนั้นคุณตั้งค่าไฟล์for-loopเพื่อทำซ้ำบนผลลัพธ์ หากหมายเลขเอาต์พุตในซีรีส์ต่ำกว่าช่วงอินพุตที่แมปคุณจะเปิดใช้งาน ถ้าไม่คุณปิด

ผลลัพธ์

คุณจะเห็น LED เปิดทีละรายการเมื่อค่าของการอ่านอนาล็อกเพิ่มขึ้นและปิดทีละรายการในขณะที่การอ่านกำลังลดลง

ตัวอย่างนี้ใช้ไลบรารีคีย์บอร์ดเพื่อล็อกคุณออกจากเซสชันผู้ใช้บนคอมพิวเตอร์ของคุณเมื่อพิน 2 บน ARDUINO UNO ถูกดึงลงกราวด์ ภาพร่างจำลองการกดแป้นตามลำดับของปุ่มสองหรือสามปุ่มในเวลาเดียวกันและหลังจากหน่วงเวลาสั้น ๆ มันจะปล่อยออกมา

Warning - เมื่อคุณใช้ไฟล์ Keyboard.print()คำสั่ง Arduino เข้าควบคุมแป้นพิมพ์ของคอมพิวเตอร์ของคุณ เพื่อให้แน่ใจว่าคุณจะไม่สูญเสียการควบคุมคอมพิวเตอร์ของคุณในขณะที่เรียกใช้ร่างด้วยฟังก์ชันนี้ให้ตั้งค่าระบบควบคุมที่เชื่อถือได้ก่อนที่คุณจะเรียก Keyboard.print () ภาพร่างนี้ออกแบบมาเพื่อส่งคำสั่ง Keyboard หลังจากดึงพินลงกราวด์แล้วเท่านั้น

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Leonardo, Micro หรือ Due board
• 1 ×ปุ่มกด
• 1 ×จัมเปอร์

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

สำหรับตัวอย่างนี้คุณต้องใช้ Arduino IDE 1.6.7

Note- คุณต้องรวมไลบรารีคีย์บอร์ดไว้ในไฟล์ไลบรารี Arduino ของคุณ คัดลอกและวางไฟล์ไลบรารีปุ่มกดภายในไฟล์ด้วยไลบรารีชื่อ (ไฮไลต์) ดังที่แสดงในภาพหน้าจอต่อไปนี้

รหัส Arduino

/*
   Keyboard logout
   This sketch demonstrates the Keyboard library.
   When you connect pin 2 to ground, it performs a logout.
   It uses keyboard combinations to do this, as follows:
   On Windows, CTRL-ALT-DEL followed by ALT-l
   On Ubuntu, CTRL-ALT-DEL, and ENTER
   On OSX, CMD-SHIFT-q
   To wake: Spacebar.
   Circuit:
   * Arduino Leonardo or Micro
   * wire to connect D2 to ground.
*/

#define OSX 0
#define WINDOWS 1
#define UBUNTU 2

#include "Keyboard.h"

// change this to match your platform:
int platform = WINDOWS;

void setup() {
   // make pin 2 an input and turn on the
   // pullup resistor so it goes high unless
   // connected to ground:
   
   pinMode(2, INPUT_PULLUP);
   Keyboard.begin();
}

void loop() {
   while (digitalRead(2) == HIGH) {
      // do nothing until pin 2 goes low
      delay(500);
   }
   
   delay(1000);
   
   switch (platform) {
      case OSX:
      Keyboard.press(KEY_LEFT_GUI);
	  
      // Shift-Q logs out:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press('Q');
      delay(100);
	  
      // enter:
      Keyboard.write(KEY_RETURN);
      break;
	  
      case WINDOWS:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
      //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
      case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
	  
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
   // do nothing:
   while (true);
}

Keyboard.releaseAll();

   // enter:
      Keyboard.write(KEY_RETURN);
      break;
      case WINDOWS:
	  
   // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
   //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
   case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
// do nothing:
   while (true);
}

รหัสที่ควรทราบ

ก่อนที่คุณจะอัปโหลดโปรแกรมไปยังบอร์ดของคุณตรวจสอบให้แน่ใจว่าคุณได้กำหนดระบบปฏิบัติการที่ถูกต้องที่คุณกำลังใช้ให้กับตัวแปรแพลตฟอร์ม

ในขณะที่ร่างกำลังทำงานอยู่การกดปุ่มจะเชื่อมต่อพิน 2 เข้ากับกราวด์และบอร์ดจะส่งลำดับการล็อกเอาต์ไปยังพีซีที่เชื่อมต่อ USB

ผลลัพธ์

เมื่อคุณเชื่อมต่อพิน 2 เข้ากับกราวด์จะดำเนินการล็อกเอาต์

ใช้ชุดแป้นพิมพ์ต่อไปนี้เพื่อออกจากระบบ -

• บน Windows, CTRL-ALT-DEL ตามด้วย ALT-l

• บน Ubuntu, CTRL-ALT-DEL และ ENTER

• บน OSX, CMD-SHIFT-q

ในตัวอย่างนี้เมื่อกดปุ่มสตริงข้อความจะถูกส่งไปยังคอมพิวเตอร์เป็นอินพุตแป้นพิมพ์ สตริงจะรายงานจำนวนครั้งที่กดปุ่ม เมื่อคุณตั้งโปรแกรมและต่อสายของ Leonardo แล้วให้เปิดโปรแกรมแก้ไขข้อความที่คุณชื่นชอบเพื่อดูผลลัพธ์

Warning - เมื่อคุณใช้ไฟล์ Keyboard.print()คำสั่ง Arduino จะเข้าควบคุมแป้นพิมพ์ของคอมพิวเตอร์ของคุณ เพื่อให้แน่ใจว่าคุณจะไม่สูญเสียการควบคุมคอมพิวเตอร์ของคุณในขณะที่เรียกใช้ภาพร่างด้วยฟังก์ชันนี้ให้ตั้งค่าระบบควบคุมที่เชื่อถือได้ก่อนที่คุณจะโทรKeyboard.print(). ภาพร่างนี้มีปุ่มกดเพื่อสลับแป้นพิมพ์เพื่อให้ทำงานหลังจากกดปุ่มเท่านั้น

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Leonardo, Micro หรือ Due board
• 1 ×ปุ่มกดชั่วขณะ
• ตัวต้านทาน 1 × 10k โอห์ม

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

/*
   Keyboard Message test For the Arduino Leonardo and Micro,
      Sends a text string when a button is pressed.
   The circuit:
   * pushbutton attached from pin 4 to +5V
   * 10-kilohm resistor attached from pin 4 to ground
*/

#include "Keyboard.h"
const int buttonPin = 4; // input pin for pushbutton
int previousButtonState = HIGH; // for checking the state of a pushButton
int counter = 0; // button push counter

void setup() {
   pinMode(buttonPin, INPUT); // make the pushButton pin an input:
   Keyboard.begin(); // initialize control over the keyboard:
}

void loop() {
   int buttonState = digitalRead(buttonPin); // read the pushbutton:
   if ((buttonState != previousButtonState)&& (buttonState == HIGH)) // and it's currently pressed: {
      // increment the button counter
      counter++;
      // type out a message
      Keyboard.print("You pressed the button ");
      Keyboard.print(counter);
      Keyboard.println(" times.");
   }
   // save the current button state for comparison next time:
   previousButtonState = buttonState;
}

รหัสที่ควรทราบ

แนบขั้วหนึ่งของปุ่มกดเข้ากับพิน 4 บน Arduino แนบพินอื่นเข้ากับ 5V ใช้ตัวต้านทานเป็นตัวดึงลงโดยให้อ้างอิงกับกราวด์โดยการต่อจากพิน 4 เข้ากับกราวด์

เมื่อคุณตั้งโปรแกรมบอร์ดของคุณแล้วให้ถอดสาย USB เปิดโปรแกรมแก้ไขข้อความและวางเคอร์เซอร์ข้อความในพื้นที่พิมพ์ เชื่อมต่อบอร์ดเข้ากับคอมพิวเตอร์ของคุณผ่าน USB อีกครั้งแล้วกดปุ่มเพื่อเขียนในเอกสาร

ผลลัพธ์

โดยใช้โปรแกรมแก้ไขข้อความใด ๆ จะแสดงข้อความที่ส่งผ่าน Arduino

เมื่อใช้ไลบรารีเมาส์คุณสามารถควบคุมเคอร์เซอร์บนหน้าจอของคอมพิวเตอร์ด้วย Arduino Leonardo, Micro หรือ Due

ตัวอย่างนี้ใช้ปุ่มกดห้าปุ่มเพื่อเลื่อนเคอร์เซอร์บนหน้าจอ ปุ่มสี่ปุ่มมีทิศทาง (ขึ้นลงซ้ายขวา) และปุ่มหนึ่งสำหรับคลิกเมาส์ซ้าย การเคลื่อนไหวของเคอร์เซอร์จาก Arduino นั้นสัมพันธ์กันเสมอ ทุกครั้งที่อ่านข้อมูลเข้าตำแหน่งของเคอร์เซอร์จะได้รับการอัปเดตโดยสัมพันธ์กับตำแหน่งปัจจุบัน

เมื่อใดก็ตามที่กดปุ่มทิศทางใดปุ่มหนึ่ง Arduino จะเลื่อนเมาส์โดยจับคู่อินพุต HIGH ไปยังช่วง 5 ในทิศทางที่เหมาะสม

ปุ่มที่ห้าใช้สำหรับควบคุมการคลิกซ้ายจากเมาส์ เมื่อปล่อยปุ่มคอมพิวเตอร์จะจดจำเหตุการณ์

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Leonardo, Micro หรือ Due board
• ตัวต้านทาน 5 × 10k โอห์ม
• 5 ×ปุ่มกดชั่วขณะ

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

สำหรับตัวอย่างนี้คุณต้องใช้ Arduino IDE 1.6.7

รหัส Arduino

/*
   Button Mouse Control
   For Leonardo and Due boards only .Controls the mouse from 
   five pushbuttons on an Arduino Leonardo, Micro or Due.
   Hardware:
   * 5 pushbuttons attached to D2, D3, D4, D5, D6
   The mouse movement is always relative. This sketch reads
   four pushbuttons, and uses them to set the movement of the mouse.
   WARNING: When you use the Mouse.move() command, the Arduino takes
   over your mouse! Make sure you have control before you use the mouse commands.
*/

#include "Mouse.h"
// set pin numbers for the five buttons:
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
int range = 5; // output range of X or Y movement; affects movement speed
int responseDelay = 10; // response delay of the mouse, in ms

void setup() {
   // initialize the buttons' inputs:
   pinMode(upButton, INPUT);
   pinMode(downButton, INPUT);
   pinMode(leftButton, INPUT);
   pinMode(rightButton, INPUT);
   pinMode(mouseButton, INPUT);
   // initialize mouse control:
   Mouse.begin();
}

void loop() {
   // read the buttons:
   int upState = digitalRead(upButton);
   int downState = digitalRead(downButton);
   int rightState = digitalRead(rightButton);
   int leftState = digitalRead(leftButton);
   int clickState = digitalRead(mouseButton);
   // calculate the movement distance based on the button states:
   int xDistance = (leftState - rightState) * range;
   int yDistance = (upState - downState) * range;
   // if X or Y is non-zero, move:
   if ((xDistance != 0) || (yDistance != 0)) {
      Mouse.move(xDistance, yDistance, 0);
   }

   // if the mouse button is pressed:
   if (clickState == HIGH) {
      // if the mouse is not pressed, press it:
      if (!Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.press(MOUSE_LEFT);
      }
   } else {                           // else the mouse button is not pressed:
      // if the mouse is pressed, release it:
      if (Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.release(MOUSE_LEFT);
      }
   }
   // a delay so the mouse does not move too fast:
   delay(responseDelay);
}

รหัสที่ควรทราบ

เชื่อมต่อบอร์ดของคุณเข้ากับคอมพิวเตอร์ด้วยสายไมโคร USB ปุ่มต่างๆเชื่อมต่อกับอินพุตดิจิตอลตั้งแต่พิน 2 ถึง 6 ตรวจสอบให้แน่ใจว่าคุณใช้ตัวต้านทานแบบดึงลง 10k

ตัวอย่างนี้ฟังไบต์ที่มาจากพอร์ตอนุกรม เมื่อได้รับบอร์ดจะส่งการกดแป้นพิมพ์กลับไปที่คอมพิวเตอร์ การกดแป้นพิมพ์ที่ส่งจะสูงกว่าที่ได้รับดังนั้นหากคุณส่ง "a" จากจอภาพอนุกรมคุณจะได้รับ "b" จากบอร์ดที่เชื่อมต่อกับคอมพิวเตอร์ "1" จะส่งคืน "2" และอื่น ๆ

Warning - เมื่อคุณใช้ไฟล์ Keyboard.print()คำสั่งบอร์ด Leonardo, Micro หรือ Due จะเข้าควบคุมแป้นพิมพ์ของคอมพิวเตอร์ของคุณ เพื่อให้แน่ใจว่าคุณจะไม่สูญเสียการควบคุมคอมพิวเตอร์ของคุณในขณะที่เรียกใช้ร่างด้วยฟังก์ชันนี้ให้ตั้งค่าระบบควบคุมที่เชื่อถือได้ก่อนที่คุณจะเรียก Keyboard.print () ภาพร่างนี้ออกแบบมาเพื่อส่งคำสั่ง Keyboard หลังจากที่บอร์ดได้รับไบต์ผ่านพอร์ตอนุกรมเท่านั้น

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 × Arduino Leonardo, Micro หรือ Due board

ขั้นตอน

เพียงแค่เชื่อมต่อบอร์ดของคุณเข้ากับคอมพิวเตอร์โดยใช้สาย USB

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

Notes- คุณต้องรวมไลบรารีปุ่มกดในไฟล์ไลบรารี Arduino ของคุณ คัดลอกและวางไฟล์ไลบรารีปุ่มกดภายในไฟล์โดยเน้นชื่อ 'libraries' ด้วยสีเหลือง

รหัส Arduino

/*
   Keyboard test
   For the Arduino Leonardo, Micro or Due Reads
      a byte from the serial port, sends a keystroke back. 
   The sent keystroke is one higher than what's received, e.g. if you send a, you get b, send
      A you get B, and so forth.
   The circuit:
   * none
*/

#include "Keyboard.h"

void setup() {
   // open the serial port:
   Serial.begin(9600);
   // initialize control over the keyboard:
   Keyboard.begin();
}

void loop() {
   // check for incoming serial data:
   if (Serial.available() > 0) {
      // read incoming serial data:
      char inChar = Serial.read();
      // Type the next ASCII value from what you received:
      Keyboard.write(inChar + 1);
   }
}

รหัสที่ควรทราบ

เมื่อตั้งโปรแกรมแล้วให้เปิดมอนิเตอร์แบบอนุกรมของคุณแล้วส่งไบต์ บอร์ดจะตอบกลับด้วยการกดแป้นพิมพ์ซึ่งสูงกว่าหนึ่งหมายเลข

ผลลัพธ์

บอร์ดจะตอบกลับด้วยการกดแป้นพิมพ์ที่สูงกว่าหนึ่งหมายเลขบนจอภาพอนุกรม Arduino IDE เมื่อคุณส่งไบต์

ในส่วนนี้เราจะเรียนรู้วิธีการเชื่อมต่อบอร์ด Arduino กับเซ็นเซอร์ต่างๆ เราจะพูดถึงเซ็นเซอร์ต่อไปนี้ -

• เซ็นเซอร์ความชื้น (DHT22)
• เซ็นเซอร์อุณหภูมิ (LM35)
• เซ็นเซอร์ตรวจจับน้ำ (Simple Water Trigger)
• เซ็นเซอร์ PIR
• เซ็นเซอร์อัลตราโซนิก
• GPS

เซ็นเซอร์ความชื้น (DHT22)

DHT-22 (มีชื่อเรียกอีกอย่างว่า AM2302) เป็นเอาต์พุตดิจิตอลความชื้นสัมพัทธ์และเซ็นเซอร์อุณหภูมิ ใช้เซ็นเซอร์ความชื้นแบบ capacitive และเทอร์มิสเตอร์เพื่อวัดอากาศโดยรอบและส่งสัญญาณดิจิทัลบนพินข้อมูล

ในตัวอย่างนี้คุณจะได้เรียนรู้วิธีใช้เซ็นเซอร์นี้กับ Arduino UNO อุณหภูมิห้องและความชื้นจะถูกพิมพ์ไปยังจอภาพแบบอนุกรม

เซ็นเซอร์ DHT-22

การเชื่อมต่อทำได้ง่าย พินแรกทางด้านซ้ายถึงไฟ 3-5V พินที่สองไปยังพินอินพุตข้อมูลและพินขวาสุดลงกราวด์

รายละเอียดทางเทคนิค

• Power - 3-5V

• Max Current - 2.5mA

• Humidity - ความแม่นยำ 0-100%, 2-5%

• Temperature - 40 ถึง 80 ° C, ความแม่นยำ± 0.5 ° C

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• 1 × DHT22
• ตัวต้านทาน 1 × 10K โอห์ม

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

// Example testing sketch for various DHT humidity/temperature sensors

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
   Serial.begin(9600);
   Serial.println("DHTxx test!");
   dht.begin();
}

void loop() {
   delay(2000); // Wait a few seconds between measurements
   float h = dht.readHumidity();
   // Reading temperature or humidity takes about 250 milliseconds!
   float t = dht.readTemperature();
   // Read temperature as Celsius (the default)
   float f = dht.readTemperature(true);
   // Read temperature as Fahrenheit (isFahrenheit = true)
   // Check if any reads failed and exit early (to try again).
   if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }
   
   // Compute heat index in Fahrenheit (the default)
   float hif = dht.computeHeatIndex(f, h);
   // Compute heat index in Celsius (isFahreheit = false)
   float hic = dht.computeHeatIndex(t, h, false);
   Serial.print ("Humidity: ");
   Serial.print (h);
   Serial.print (" %\t");
   Serial.print ("Temperature: ");
   Serial.print (t);
   Serial.print (" *C ");
   Serial.print (f);
   Serial.print (" *F\t");
   Serial.print ("Heat index: ");
   Serial.print (hic);
   Serial.print (" *C ");
   Serial.print (hif);
   Serial.println (" *F");
}

รหัสที่ควรทราบ

เซ็นเซอร์ DHT22 มีสี่ขั้ว (V _cc , DATA, NC, GND) ซึ่งเชื่อมต่อกับบอร์ดดังนี้ -

• DATA pin ไปยัง Arduino pin หมายเลข 2
• V _cc pin ถึงบอร์ด Arduino 5 โวลต์
• GND ปักหมุดที่พื้นบอร์ด Arduino
• เราจำเป็นต้องเชื่อมต่อตัวต้านทาน 10k โอห์ม (ตัวต้านทานแบบดึงขึ้น) ระหว่าง DATA และขาV _cc

เมื่อเชื่อมต่อฮาร์ดแวร์เสร็จแล้วคุณต้องเพิ่มไลบรารี DHT22 ลงในไฟล์ไลบรารี Arduino ของคุณตามที่อธิบายไว้ก่อนหน้านี้

ผลลัพธ์

คุณจะเห็นอุณหภูมิและความชื้นที่แสดงบนจอภาพพอร์ตอนุกรมซึ่งจะอัปเดตทุกๆ 2 วินาที

เซนเซอร์จับอุณหภูมิ LM35 ซีรี่ส์เป็นอุปกรณ์วัดอุณหภูมิในวงจรรวมที่มีความแม่นยำโดยมีแรงดันไฟฟ้าขาออกเป็นสัดส่วนเชิงเส้นกับอุณหภูมิองศาเซนติเกรด

อุปกรณ์ LM35 มีข้อได้เปรียบเหนือเซ็นเซอร์อุณหภูมิเชิงเส้นที่ปรับเทียบเป็นเคลวินเนื่องจากผู้ใช้ไม่จำเป็นต้องลบแรงดันไฟฟ้าคงที่ขนาดใหญ่ออกจากเอาต์พุตเพื่อให้ได้มาตราส่วน Centigrade ที่สะดวก อุปกรณ์ LM35 ไม่จำเป็นต้องมีการสอบเทียบภายนอกหรือการตัดแต่งใด ๆ เพื่อให้ได้ความแม่นยำทั่วไปของ±¼° C ที่อุณหภูมิห้องและ±¾° C ในช่วงอุณหภูมิเต็ม −55 ° C ถึง 150 ° C

ข้อกำหนดทางเทคนิค

• ปรับเทียบโดยตรงในเซลเซียส (องศาเซลเซียส)
• Linear + 10-mV / ° C สเกลแฟคเตอร์
• 0.5 ° C มั่นใจในความแม่นยำ (ที่ 25 ° C)
• ได้รับการจัดอันดับสำหรับช่วง −55 ° C ถึง 150 ° C เต็ม
• เหมาะสำหรับการใช้งานระยะไกล

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• 1 × LM35 เซ็นเซอร์

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

float temp;
int tempPin = 0;

void setup() {
   Serial.begin(9600);
}

void loop() {
   temp = analogRead(tempPin);
   // read analog volt from sensor and save to variable temp
   temp = temp * 0.48828125;
   // convert the analog volt to its temperature equivalent
   Serial.print("TEMPERATURE = ");
   Serial.print(temp); // display temperature value
   Serial.print("*C");
   Serial.println();
   delay(1000); // update sensor reading each one second
}

รหัสที่ควรทราบ

เซ็นเซอร์ LM35 มีขั้วสามขั้ว - V _s , V _outและ GND เราจะเชื่อมต่อเซ็นเซอร์ดังต่อไปนี้ -

• เชื่อมต่อ + V _sถึง + 5v บนบอร์ด Arduino ของคุณ
• เชื่อมต่อ V _outกับ Analog0 หรือ A0 บนบอร์ด Arduino
• เชื่อมต่อ GND กับ GND บน Arduino

ตัวแปลงอนาล็อกเป็นดิจิตอล (ADC) จะแปลงค่าอนาล็อกเป็นการประมาณแบบดิจิทัลตามสูตรค่า ADC = ตัวอย่าง * 1024 / แรงดันอ้างอิง (+ 5v) ดังนั้นด้วยการอ้างอิง +5 โวลต์การประมาณแบบดิจิทัลจะเท่ากับแรงดันไฟฟ้าอินพุต * 205

ผลลัพธ์

คุณจะเห็นการแสดงอุณหภูมิบนจอภาพพอร์ตอนุกรมซึ่งมีการอัปเดตทุกวินาที

อิฐเซ็นเซอร์น้ำถูกออกแบบมาสำหรับการตรวจจับน้ำซึ่งสามารถใช้กันอย่างแพร่หลายในการตรวจจับปริมาณน้ำฝนระดับน้ำและแม้กระทั่งการรั่วไหลของของเหลว

การเชื่อมต่อเซ็นเซอร์น้ำเข้ากับ Arduino เป็นวิธีที่ยอดเยี่ยมในการตรวจจับการรั่วไหลการรั่วไหลน้ำท่วมฝน ฯลฯ สามารถใช้เพื่อตรวจจับการมีอยู่ระดับปริมาตรและ / หรือการขาดน้ำ แม้ว่าจะใช้เพื่อเตือนให้คุณรดน้ำต้นไม้ แต่ก็มีเซ็นเซอร์ Grove ที่ดีกว่าสำหรับสิ่งนั้น เซ็นเซอร์มีอาร์เรย์ของร่องรอยที่สัมผัสซึ่งจะอ่าน LOW เมื่อตรวจพบน้ำ

ในบทนี้เราจะเชื่อมต่อเซ็นเซอร์น้ำกับ Digital Pin 8 บน Arduino และจะขอใช้ LED ที่มีประโยชน์มากเพื่อช่วยในการระบุเมื่อเซ็นเซอร์น้ำสัมผัสกับแหล่งน้ำ

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• 1 ×เซ็นเซอร์น้ำ
• 1 ×นำ
• ตัวต้านทาน 1 × 330 โอห์ม

ขั้นตอน

ทำตามแผนภาพวงจรและต่อส่วนประกอบบนเขียงหั่นขนมดังแสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกที่ใหม่

รหัส Arduino

#define Grove_Water_Sensor 8 // Attach Water sensor to Arduino Digital Pin 8
#define LED 9 // Attach an LED to Digital Pin 9 (or use onboard LED)

void setup() {
   pinMode(Grove_Water_Sensor, INPUT); // The Water Sensor is an Input
   pinMode(LED, OUTPUT); // The LED is an Output
}

void loop() {
   /* The water sensor will switch LOW when water is detected.
   Get the Arduino to illuminate the LED and activate the buzzer
   when water is detected, and switch both off when no water is present */
   if( digitalRead(Grove_Water_Sensor) == LOW) {
      digitalWrite(LED,HIGH);
   }else {
      digitalWrite(LED,LOW);
   }
}

รหัสที่ควรทราบ

เซ็นเซอร์น้ำมีขั้วสามขั้ว - S, V _out (+) และ GND (-) เชื่อมต่อเซ็นเซอร์ดังต่อไปนี้ -

• เชื่อมต่อ + V _sถึง + 5v บนบอร์ด Arduino ของคุณ
• เชื่อมต่อ S กับพินดิจิตอล 8 บนบอร์ด Arduino
• เชื่อมต่อ GND กับ GND บน Arduino
• เชื่อมต่อ LED เข้ากับพินดิจิทัลหมายเลข 9 ในบอร์ด Arduino

เมื่อเซ็นเซอร์ตรวจจับน้ำขา 8 บน Arduino จะกลายเป็น LOW จากนั้น LED บน Arduino จะเปิดขึ้น

ผลลัพธ์

คุณจะเห็นไฟ LED แสดงสถานะเปิดเมื่อเซ็นเซอร์ตรวจพบน้ำ

เซ็นเซอร์ PIR ช่วยให้คุณรับรู้การเคลื่อนไหว ใช้เพื่อตรวจจับว่ามนุษย์ย้ายเข้าหรือออกจากระยะของเซ็นเซอร์หรือไม่ มักพบในเครื่องใช้และอุปกรณ์ต่างๆที่ใช้ในบ้านหรือสำหรับธุรกิจ ซึ่งมักเรียกกันว่าเซ็นเซอร์ PIR, "Passive Infrared", "Pyroelectric" หรือ "IR motion"

ต่อไปนี้เป็นข้อดีของเซ็นเซอร์ PIR -

• ขนาดเล็ก
• ช่วงเลนส์กว้าง
• ง่ายต่อการเชื่อมต่อ
• Inexpensive
• Low-power
• ง่ายต่อการใช้
• อย่าใส่ออกไป

PIR ทำจากไพโรอิเล็กทริกเซนเซอร์กระป๋องโลหะทรงกลมที่มีคริสตัลสี่เหลี่ยมอยู่ตรงกลางซึ่งสามารถตรวจจับระดับของรังสีอินฟราเรดได้ ทุกอย่างปล่อยรังสีระดับต่ำและสิ่งที่ร้อนกว่าก็คือยิ่งมีการแผ่รังสีออกมามากขึ้น เซ็นเซอร์ในเครื่องตรวจจับการเคลื่อนไหวถูกแบ่งออกเป็นสองส่วน นี่คือการตรวจจับการเคลื่อนไหว (การเปลี่ยนแปลง) ไม่ใช่ระดับ IR เฉลี่ย ทั้งสองซีกเชื่อมต่อกันเพื่อให้ตัดกัน หากครึ่งหนึ่งเห็นรังสี IR มากกว่าหรือน้อยกว่าอีกด้านหนึ่งเอาต์พุตจะแกว่งสูงหรือต่ำ

PIR มีการตั้งค่าที่ปรับได้และมีส่วนหัวติดตั้งอยู่ในแผ่นกราวด์ / ขาออก / ไฟ 3 ขา

สำหรับโครงการหรือผลิตภัณฑ์พื้นฐานจำนวนมากที่ต้องตรวจจับเมื่อบุคคลออกไปหรือเข้ามาในพื้นที่เซ็นเซอร์ PIR นั้นยอดเยี่ยมมาก โปรดทราบว่า PIR ไม่ได้บอกจำนวนคนรอบข้างหรือความใกล้ชิดกับเซ็นเซอร์ เลนส์มักจะถูกจับจ้องไปที่การกวาดในระยะไกลและบางครั้งสัตว์เลี้ยงในบ้านก็ถูกทิ้งไว้

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• 1 × PIR เซนเซอร์ (MQ3)

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อดังแสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

#define pirPin 2
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 5000;
boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;

void setup() {
   Serial.begin(9600);
   pinMode(pirPin, INPUT);
}

void loop() {
   PIRSensor();
}

void PIRSensor() {
   if(digitalRead(pirPin) == HIGH) {
      if(lockLow) {
         PIRValue = 1;
         lockLow = false;
         Serial.println("Motion detected.");
         delay(50);
      }
      takeLowTime = true;
   }
   if(digitalRead(pirPin) == LOW) {
      if(takeLowTime){
         lowIn = millis();takeLowTime = false;
      }
      if(!lockLow && millis() - lowIn > pause) {
         PIRValue = 0;
         lockLow = true;
         Serial.println("Motion ended.");
         delay(50);
      }
   }
}

รหัสที่ควรทราบ

เซ็นเซอร์ PIR มีสามขั้ว - V _cc , OUT และ GND เชื่อมต่อเซ็นเซอร์ดังต่อไปนี้ -

• เชื่อมต่อ + V _ccถึง + 5v บนบอร์ด Arduino
• เชื่อมต่อ OUT กับพินดิจิตอล 2 บนบอร์ด Arduino
• เชื่อมต่อ GND กับ GND บน Arduino

คุณสามารถปรับความไวของเซ็นเซอร์และเวลาหน่วงผ่านตัวต้านทานตัวแปรสองตัวที่ด้านล่างของแผงเซ็นเซอร์

เมื่อเซ็นเซอร์ตรวจพบการเคลื่อนไหว Arduino จะส่งข้อความผ่านพอร์ตอนุกรมเพื่อแจ้งว่าตรวจพบการเคลื่อนไหว การเคลื่อนไหวแบบสัมผัส PIR จะหน่วงเวลาเป็นระยะเวลาหนึ่งเพื่อตรวจสอบว่ามีการเคลื่อนไหวใหม่ หากตรวจไม่พบการเคลื่อนไหว Arduino จะส่งข้อความใหม่แจ้งว่าการเคลื่อนไหวสิ้นสุดลงแล้ว

ผลลัพธ์

คุณจะเห็นข้อความบนพอร์ตอนุกรมของคุณหากตรวจพบการเคลื่อนไหวและข้อความอื่นเมื่อการเคลื่อนไหวหยุดลง

เซ็นเซอร์อัลตราโซนิก HC-SR04 ใช้ SONAR เพื่อกำหนดระยะห่างของวัตถุเช่นเดียวกับที่ค้างคาวทำ มีการตรวจจับระยะไม่สัมผัสที่ยอดเยี่ยมพร้อมความแม่นยำสูงและการอ่านที่เสถียรในแพ็คเกจที่ใช้งานง่ายตั้งแต่ 2 ซม. ถึง 400 ซม. หรือ 1 นิ้วถึง 13 ฟุต

การทำงานไม่ได้รับผลกระทบจากแสงแดดหรือวัสดุสีดำแม้ว่าวัสดุที่อ่อนนุ่มเช่นผ้าอาจตรวจจับได้ยาก มาพร้อมกับโมดูลเครื่องส่งและตัวรับสัญญาณอัลตราโซนิก

ข้อกำหนดทางเทคนิค

• แหล่งจ่ายไฟ - + 5V DC
• กระแสไฟฟ้าดับ - <2mA
• การทำงานปัจจุบัน - 15mA
• มุมผล - <15 °
• ตั้งแต่ระยะทาง - 2 ซม. - 400 ซม. / 1″ - 13 ฟุต
• ความละเอียด - 0.3 ซม
• มุมการวัด - 30 องศา

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×เขียงหั่นขนม
• 1 × Arduino Uno R3
• 1 ×เซ็นเซอร์อัลตราโซนิก (HC-SR04)

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อตามที่แสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

const int pingPin = 7; // Trigger Pin of Ultrasonic Sensor
const int echoPin = 6; // Echo Pin of Ultrasonic Sensor

void setup() {
   Serial.begin(9600); // Starting Serial Terminal
}

void loop() {
   long duration, inches, cm;
   pinMode(pingPin, OUTPUT);
   digitalWrite(pingPin, LOW);
   delayMicroseconds(2);
   digitalWrite(pingPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(pingPin, LOW);
   pinMode(echoPin, INPUT);
   duration = pulseIn(echoPin, HIGH);
   inches = microsecondsToInches(duration);
   cm = microsecondsToCentimeters(duration);
   Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();
   delay(100);
}

long microsecondsToInches(long microseconds) {
   return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
   return microseconds / 29 / 2;
}

รหัสที่ควรทราบ

เซ็นเซอร์อัลตราโซนิกมีสี่ขั้ว - + 5V, Trigger, Echo และ GND เชื่อมต่อดังนี้ -

• เชื่อมต่อ + 5V พินกับ + 5v บนบอร์ด Arduino ของคุณ
• เชื่อมต่อ Trigger กับพินดิจิตอล 7 บนบอร์ด Arduino ของคุณ
• เชื่อมต่อ Echo กับพินดิจิตอล 6 บนบอร์ด Arduino ของคุณ
• เชื่อมต่อ GND กับ GND บน Arduino

ในโปรแกรมของเราเราได้แสดงระยะทางที่เซ็นเซอร์วัดเป็นนิ้วและซม. ผ่านพอร์ตอนุกรม

ผลลัพธ์

คุณจะเห็นระยะทางที่วัดโดยเซ็นเซอร์เป็นนิ้วและซม. บนจอภาพอนุกรม Arduino

ปุ่มกดหรือสวิตช์เชื่อมต่อขั้วเปิดสองขั้วในวงจร ตัวอย่างนี้จะเปิด LED ที่ขา 2 เมื่อคุณกดสวิตช์ปุ่มกดที่เชื่อมต่อกับพิน 8

ตัวต้านทานแบบดึงลง

ตัวต้านทานแบบดึงลงใช้ในวงจรลอจิกอิเล็กทรอนิกส์เพื่อให้แน่ใจว่าอินพุตไปยัง Arduino จะอยู่ในระดับตรรกะที่คาดไว้หากอุปกรณ์ภายนอกถูกตัดการเชื่อมต่อหรือมีความต้านทานสูง เนื่องจากไม่มีอะไรเชื่อมต่อกับพินอินพุตจึงไม่ได้หมายความว่าเป็นศูนย์ตรรกะ ตัวต้านทานแบบดึงลงจะเชื่อมต่อระหว่างกราวด์และพินที่เหมาะสมบนอุปกรณ์

ตัวอย่างของตัวต้านทานแบบดึงลงในวงจรดิจิทัลแสดงในรูปต่อไปนี้ สวิตช์ปุ่มกดเชื่อมต่อระหว่างแรงดันไฟฟ้าและขาไมโครคอนโทรลเลอร์ ในวงจรดังกล่าวเมื่อปิดสวิตช์อินพุตไมโครคอนโทรลเลอร์จะมีค่าสูงเชิงตรรกะ แต่เมื่อสวิตช์เปิดอยู่ตัวต้านทานแบบดึงลงจะดึงแรงดันไฟฟ้าอินพุตลงไปที่พื้น (ค่าศูนย์เชิงตรรกะ) เพื่อป้องกัน สถานะที่ไม่ได้กำหนดไว้ที่อินพุต

ตัวต้านทานแบบดึงลงต้องมีความต้านทานมากกว่าอิมพีแดนซ์ของวงจรลอจิกมิฉะนั้นอาจดึงแรงดันไฟฟ้าลงมากเกินไปและแรงดันไฟฟ้าขาเข้าที่พินจะยังคงอยู่ที่ค่าต่ำลอจิคัลคงที่โดยไม่คำนึงถึงตำแหน่งสวิตช์

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×บอร์ด Arduino UNO
• ตัวต้านทาน 1 × 330 โอห์ม
• ตัวต้านทาน 1 × 4.7K โอห์ม (ดึงลง)
• 1 × LED

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อตามที่แสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกที่ใหม่

รหัส Arduino

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
const int ledPin = 2; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
   // initialize the LED pin as an output:
   pinMode(ledPin, OUTPUT);
   // initialize the pushbutton pin as an input:
   pinMode(buttonPin, INPUT);
}

void loop() {
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
   // check if the pushbutton is pressed.
   // if it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
      // turn LED on:
      digitalWrite(ledPin, HIGH);
   } else {
      // turn LED off:
      digitalWrite(ledPin, LOW);
   }
}

รหัสที่ควรทราบ

เมื่อสวิตช์เปิดอยู่ (ไม่ได้กดปุ่มกด) ไม่มีการเชื่อมต่อระหว่างขั้วทั้งสองของปุ่มกดดังนั้นพินจึงเชื่อมต่อกับกราวด์ (ผ่านตัวต้านทานแบบดึงลง) และเราอ่านค่า LOW เมื่อสวิตช์ถูกปิด (กดปุ่มกด) มันจะทำการเชื่อมต่อระหว่างขั้วทั้งสองโดยเชื่อมต่อพินเป็น 5 โวลต์เพื่อให้เราอ่านค่าสูง

ผลลัพธ์

LED จะเปิดเมื่อกดปุ่มและปิดเมื่อปล่อย

ในบทนี้เราจะเชื่อมต่อมอเตอร์ประเภทต่างๆกับบอร์ด Arduino (UNO) และแสดงวิธีการเชื่อมต่อมอเตอร์และขับเคลื่อนจากบอร์ดของคุณ

มอเตอร์มีสามประเภทที่แตกต่างกัน -

• มอเตอร์กระแสตรง
• เซอร์โวมอเตอร์
• สเต็ปเปอร์มอเตอร์

มอเตอร์กระแสตรง (มอเตอร์กระแสตรง) เป็นมอเตอร์ประเภทที่พบบ่อยที่สุด โดยปกติมอเตอร์กระแสตรงจะมีสายนำเพียงสองตัวคือหนึ่งขั้วบวกและขั้วลบ หากคุณเชื่อมต่อสายนำทั้งสองนี้เข้ากับแบตเตอรี่โดยตรงมอเตอร์จะหมุน หากคุณเปลี่ยนโอกาสในการขายมอเตอร์จะหมุนไปในทิศทางตรงกันข้าม

Warning- อย่าขับมอเตอร์โดยตรงจากหมุดบอร์ด Arduino เพราะอาจทำให้บอร์ดเสียหายได้ ใช้วงจรขับหรือ IC

เราจะแบ่งบทนี้ออกเป็นสามส่วน -

• เพียงแค่ทำให้มอเตอร์ของคุณหมุน
• ควบคุมความเร็วมอเตอร์
• ควบคุมทิศทางการหมุนของมอเตอร์กระแสตรง

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• บอร์ด Arduino UNO 1x
• 1x PN2222 ทรานซิสเตอร์
• 1x ขนาดเล็ก 6V DC เครื่องยนต์
• 1x 1N4001 ไดโอด
• ตัวต้านทาน 1x 270 Ω

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อตามที่แสดงในภาพด้านล่าง

ข้อควรระวัง

ปฏิบัติตามข้อควรระวังต่อไปนี้ขณะทำการเชื่อมต่อ

• ขั้นแรกตรวจสอบให้แน่ใจว่าได้เชื่อมต่อทรานซิสเตอร์อย่างถูกวิธี ด้านแบนของทรานซิสเตอร์ควรหันหน้าเข้าหาบอร์ด Arduino ดังที่แสดงในการจัดเรียง

• ประการที่สองปลายลายของไดโอดควรอยู่ตรงกับสายไฟ + 5V ตามการจัดเรียงที่แสดงในภาพ

Spin ControlArduino รหัส

int motorPin = 3;

void setup() {

}

void loop() {
   digitalWrite(motorPin, HIGH);
}

รหัสที่ควรทราบ

ทรานซิสเตอร์ทำหน้าที่เหมือนสวิตช์ควบคุมไฟไปยังมอเตอร์ Arduino pin 3 ใช้เพื่อเปิดและปิดทรานซิสเตอร์และได้รับชื่อ 'motorPin' ในภาพร่าง

ผลลัพธ์

มอเตอร์จะหมุนด้วยความเร็วเต็มที่เมื่อขา Arduino หมายเลข 3 สูงขึ้น

การควบคุมความเร็วมอเตอร์

ต่อไปนี้เป็นแผนผังของมอเตอร์กระแสตรงที่เชื่อมต่อกับบอร์ด Arduino

รหัส Arduino

int motorPin = 9;

void setup() {
   pinMode(motorPin, OUTPUT);
   Serial.begin(9600);
   while (! Serial);
   Serial.println("Speed 0 to 255");
}

void loop() {
   if (Serial.available()) {
      int speed = Serial.parseInt();
      if (speed >= 0 && speed <= 255) {
         analogWrite(motorPin, speed);
      }
   }
}

รหัสที่ควรทราบ

ทรานซิสเตอร์ทำหน้าที่เหมือนสวิตช์ควบคุมกำลังของมอเตอร์ Arduino pin 3 ใช้เพื่อเปิดและปิดทรานซิสเตอร์และได้รับชื่อ 'motorPin' ในภาพร่าง

เมื่อโปรแกรมเริ่มทำงานระบบจะแจ้งให้คุณระบุค่าเพื่อควบคุมความเร็วของมอเตอร์ คุณต้องป้อนค่าระหว่าง 0 ถึง 255 ใน Serial Monitor

ในฟังก์ชัน 'loop' คำสั่ง 'Serial.parseInt' ใช้เพื่ออ่านหมายเลขที่ป้อนเป็นข้อความใน Serial Monitor และแปลงเป็น 'int' คุณสามารถพิมพ์ตัวเลขใดก็ได้ที่นี่ คำสั่ง 'if' ในบรรทัดถัดไปจะเขียนแบบอะนาล็อกด้วยตัวเลขนี้ถ้าตัวเลขอยู่ระหว่าง 0 ถึง 255

ผลลัพธ์

มอเตอร์กระแสตรงจะหมุนด้วยความเร็วที่แตกต่างกันตามค่า (0 ถึง 250) ที่ได้รับทางพอร์ตอนุกรม

การควบคุมทิศทางการหมุน

ในการควบคุมทิศทางการหมุนของมอเตอร์กระแสตรงโดยไม่ต้องเปลี่ยนสายนำคุณสามารถใช้วงจรที่เรียกว่า H-Bridge. สะพาน H เป็นวงจรอิเล็กทรอนิกส์ที่สามารถขับเคลื่อนมอเตอร์ได้ทั้งสองทิศทาง H-bridges ถูกใช้ในแอพพลิเคชั่นต่างๆมากมาย หนึ่งในแอพพลิเคชั่นทั่วไปคือการควบคุมมอเตอร์ในหุ่นยนต์ เรียกว่าสะพาน H เนื่องจากใช้ทรานซิสเตอร์สี่ตัวเชื่อมต่อกันในลักษณะที่แผนผังมีลักษณะเป็น "H"

เราจะใช้ L298 H-Bridge IC ที่นี่ L298 สามารถควบคุมความเร็วและทิศทางของมอเตอร์กระแสตรงและมอเตอร์สเต็ปเปอร์และสามารถควบคุมมอเตอร์สองตัวพร้อมกันได้ พิกัดกระแสคือ 2A สำหรับมอเตอร์แต่ละตัว อย่างไรก็ตามในกระแสเหล่านี้คุณจะต้องใช้ตัวระบายความร้อน

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 × L298 สะพาน IC
• 1 × DC มอเตอร์
• 1 × Arduino UNO
• 1 ×เขียงหั่นขนม
• สายจัมเปอร์ 10 ×

ขั้นตอน

ต่อไปนี้เป็นแผนผังของอินเทอร์เฟซมอเตอร์กระแสตรงกับบอร์ด Arduino Uno

แผนภาพด้านบนแสดงวิธีการเชื่อมต่อ L298 IC เพื่อควบคุมมอเตอร์สองตัว มีขาอินพุตสามขาสำหรับมอเตอร์แต่ละตัวคือ Input1 (IN1), Input2 (IN2) และ Enable1 (EN1) สำหรับ Motor1 และ Input3, Input4 และ Enable2 สำหรับ Motor2

เนื่องจากเราจะควบคุมมอเตอร์เพียงตัวเดียวในตัวอย่างนี้เราจะเชื่อมต่อ Arduino กับ IN1 (พิน 5), IN2 (พิน 7) และ Enable1 (พิน 6) ของ L298 IC พิน 5 และ 7 เป็นแบบดิจิทัลเช่นอินพุตเปิดหรือปิดในขณะที่พิน 6 ต้องการสัญญาณมอดูเลตความกว้างพัลส์ (PWM) เพื่อควบคุมความเร็วของมอเตอร์

ตารางต่อไปนี้แสดงทิศทางที่มอเตอร์จะหมุนตามค่าดิจิตอลของ IN1 และ IN2

IN1	IN2	พฤติกรรมของมอเตอร์
		เบรค
1		ไปข้างหน้า
	1	ย้อนกลับ
1	1	เบรค

Pin IN1 ของ IC L298 เชื่อมต่อกับพิน 8 ของ Arduino ในขณะที่ IN2 เชื่อมต่อกับพิน 9 พินดิจิทัลทั้งสองของ Arduino จะควบคุมทิศทางของมอเตอร์ EN A พินของ IC เชื่อมต่อกับ PWM พิน 2 ของ Arduino สิ่งนี้จะควบคุมความเร็วของมอเตอร์

ในการตั้งค่าของ Arduino พิน 8 และ 9 เราได้ใช้ฟังก์ชัน digitalWrite () และในการตั้งค่าของพิน 2 เราต้องใช้ฟังก์ชัน analogWrite ()

ขั้นตอนการเชื่อมต่อ

• เชื่อมต่อ 5V และกราวด์ของ IC กับ 5V และกราวด์ของ Arduino ตามลำดับ
• เชื่อมต่อมอเตอร์กับพิน 2 และ 3 ของ IC
• เชื่อมต่อ IN1 ของ IC กับขา 8 ของ Arduino
• เชื่อมต่อ IN2 ของ IC เข้ากับขา 9 ของ Arduino
• เชื่อมต่อ EN1 ของ IC กับพิน 2 ของ Arduino
• เชื่อมต่อ SENS A pin ของ IC เข้ากับกราวด์
• เชื่อมต่อ Arduino โดยใช้สาย Arduino USB และอัปโหลดโปรแกรมไปยัง Arduino โดยใช้ซอฟต์แวร์ Arduino IDE
• ให้พลังงานแก่บอร์ด Arduino โดยใช้แหล่งจ่ายไฟแบตเตอรี่หรือสาย USB

รหัส Arduino

const int pwm = 2 ; //initializing pin 2 as pwm
const int in_1 = 8 ;
const int in_2 = 9 ;
//For providing logic to L298 IC to choose the direction of the DC motor

void setup() {
   pinMode(pwm,OUTPUT) ; //we have to set PWM pin as output
   pinMode(in_1,OUTPUT) ; //Logic pins are also set as output
   pinMode(in_2,OUTPUT) ;
}

void loop() {
   //For Clock wise motion , in_1 = High , in_2 = Low
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,LOW) ;
   analogWrite(pwm,255) ;
   /* setting pwm of the motor to 255 we can change the speed of rotation
   by changing pwm input but we are only using arduino so we are using highest
   value to driver the motor */
   //Clockwise for 3 secs
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
   //For Anti Clock-wise motion - IN_1 = LOW , IN_2 = HIGH
   digitalWrite(in_1,LOW) ;
   digitalWrite(in_2,HIGH) ;
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
}

ผลลัพธ์

มอเตอร์จะทำงานก่อนในทิศทางตามเข็มนาฬิกา (CW) เป็นเวลา 3 วินาทีจากนั้นทวนเข็มนาฬิกา (CCW) เป็นเวลา 3 วินาที

เซอร์โวมอเตอร์เป็นอุปกรณ์ขนาดเล็กที่มีเพลาส่งออก เพลานี้สามารถจัดตำแหน่งไปยังตำแหน่งเชิงมุมที่เฉพาะเจาะจงได้โดยการส่งสัญญาณที่เข้ารหัสเซอร์โว ตราบใดที่สัญญาณที่เข้ารหัสอยู่บนสายอินพุตเซอร์โวจะรักษาตำแหน่งเชิงมุมของเพลา หากสัญญาณที่เข้ารหัสเปลี่ยนไปตำแหน่งเชิงมุมของเพลาจะเปลี่ยนไป ในทางปฏิบัติเซอร์โวถูกใช้ในเครื่องบินบังคับวิทยุเพื่อกำหนดตำแหน่งพื้นผิวควบคุมเช่นลิฟต์และหางเสือ นอกจากนี้ยังใช้ในรถยนต์บังคับวิทยุหุ่นกระบอกและแน่นอนว่าหุ่นยนต์

เซอร์โวมีประโยชน์อย่างยิ่งในวิทยาการหุ่นยนต์ มอเตอร์มีขนาดเล็กมีวงจรควบคุมในตัวและมีประสิทธิภาพมากสำหรับขนาดของมัน เซอร์โวมาตรฐานเช่น Futaba S-148 มีแรงบิด 42 ออนซ์ / นิ้วซึ่งแข็งแกร่งสำหรับขนาดของมัน นอกจากนี้ยังดึงกำลังตามสัดส่วนกับภาระทางกล ดังนั้นเซอร์โวที่โหลดเบาจึงไม่ใช้พลังงานมากนัก

ความกล้าของเซอร์โวมอเตอร์แสดงในภาพต่อไปนี้ คุณสามารถดูวงจรควบคุมมอเตอร์ชุดเกียร์และตัวเรือน คุณยังสามารถเห็นสายไฟ 3 เส้นที่เชื่อมต่อกับโลกภายนอก หนึ่งสำหรับกำลังไฟ (+ 5 โวลต์) กราวด์และสายสีขาวคือสายควบคุม

การทำงานของเซอร์โวมอเตอร์

เซอร์โวมอเตอร์มีวงจรควบคุมและโพเทนชิออมิเตอร์ (ตัวต้านทานแบบแปรผันหรือที่เรียกว่าหม้อ) ที่เชื่อมต่อกับเพลาขาออก ในภาพด้านบนจะเห็นหม้อที่ด้านขวาของแผงวงจร หม้อนี้ช่วยให้วงจรควบคุมตรวจสอบมุมปัจจุบันของเซอร์โวมอเตอร์

หากเพลาอยู่ในมุมที่ถูกต้องมอเตอร์จะปิด หากวงจรพบว่ามุมไม่ถูกต้องก็จะหมุนมอเตอร์จนกว่าจะได้มุมที่ต้องการ เพลาส่งออกของเซอร์โวสามารถเดินทางได้ประมาณ 180 องศา โดยปกติแล้วจะอยู่ที่ไหนสักแห่งในช่วง 210 องศาอย่างไรก็ตามขึ้นอยู่กับผู้ผลิต เซอร์โวปกติใช้เพื่อควบคุมการเคลื่อนที่เชิงมุม 0 ถึง 180 องศา กลไกไม่สามารถหมุนได้ไกลขึ้นเนื่องจากกลไกหยุดที่สร้างขึ้นบนเฟืองส่งออกหลัก

กำลังไฟฟ้าที่ใช้กับมอเตอร์เป็นสัดส่วนกับระยะทางที่ต้องเดินทาง ดังนั้นหากเพลาต้องหมุนเป็นระยะทางมากมอเตอร์จะทำงานด้วยความเร็วเต็มที่ หากต้องการหมุนเพียงเล็กน้อยมอเตอร์จะทำงานด้วยความเร็วที่ช้าลง นี้เรียกว่าproportional control.

คุณสื่อสารมุมที่เซอร์โวควรหันไปอย่างไร

ลวดควบคุมใช้ในการสื่อสารมุม มุมจะถูกกำหนดโดยระยะเวลาของพัลส์ที่ใช้กับสายควบคุม นี้เรียกว่าPulse Coded Modulation. เซอร์โวคาดว่าจะเห็นชีพจรทุกๆ 20 มิลลิวินาที (.02 วินาที) ความยาวของพัลส์จะกำหนดว่ามอเตอร์หมุนไปไกลแค่ไหน ตัวอย่างเช่นพัลส์ 1.5 มิลลิวินาทีจะทำให้มอเตอร์หมุนไปที่ตำแหน่ง 90 องศา (มักเรียกว่าตำแหน่งกลาง) หากพัลส์สั้นกว่า 1.5 มิลลิวินาทีมอเตอร์จะหมุนเพลาเข้าใกล้ 0 องศา หากพัลส์ยาวเกิน 1.5 มิลลิวินาทีเพลาจะหันเข้าใกล้ 180 องศา

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×บอร์ด Arduino UNO
• 1 ×เซอร์โวมอเตอร์
• 1 × ULN2003 ขับ IC
• ตัวต้านทาน 1 × 10 KΩ

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อตามที่แสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกที่ใหม่

รหัส Arduino

/* Controlling a servo position using a potentiometer (variable resistor) */

#include <Servo.h>
   Servo myservo; // create servo object to control a servo
   int potpin = 0; // analog pin used to connect the potentiometer
   int val; // variable to read the value from the analog pin

void setup() {
   myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
   val = analogRead(potpin);
   // reads the value of the potentiometer (value between 0 and 1023)
   val = map(val, 0, 1023, 0, 180);
   // scale it to use it with the servo (value between 0 and 180)
   myservo.write(val); // sets the servo position according to the scaled value
   delay(15);
}

รหัสที่ควรทราบ

เซอร์โวมอเตอร์มีขั้วสามขั้ว - กำลังกราวด์และสัญญาณ โดยทั่วไปสายไฟจะเป็นสีแดงและควรเชื่อมต่อกับขา 5V บน Arduino โดยทั่วไปสายดินจะเป็นสีดำหรือสีน้ำตาลและควรเชื่อมต่อกับขั้วเดียวของ ULN2003 IC (10 -16) เพื่อป้องกันบอร์ด Arduino ของคุณจากความเสียหายคุณจะต้องมี IC ไดรเวอร์เพื่อทำเช่นนั้น ที่นี่เราใช้ ULN2003 IC เพื่อขับเคลื่อนเซอร์โวมอเตอร์ โดยทั่วไปขาสัญญาณจะเป็นสีเหลืองหรือสีส้มและควรเชื่อมต่อกับขา Arduino หมายเลข 9

การเชื่อมต่อโพเทนชิออมิเตอร์

ตัวแบ่งแรงดันไฟฟ้า / ตัวแบ่งศักย์เป็นตัวต้านทานในวงจรอนุกรมที่ปรับขนาดแรงดันเอาต์พุตเป็นอัตราส่วนเฉพาะของแรงดันไฟฟ้าอินพุตที่ใช้ ต่อไปนี้เป็นแผนภาพวงจร -

$$ V_ {out} = (V_ {in} \ times R_ {2}) / (R_ {1} + R_ {2}) $$

V _outคือศักย์เอาท์พุทซึ่งขึ้นอยู่กับแรงดันไฟฟ้าขาเข้าที่ใช้ (V _in ) และตัวต้านทาน (R ₁และ R ₂ ) ในซีรีส์ หมายความว่ากระแสที่ไหลผ่าน R ₁จะไหลผ่าน R ₂โดยไม่ถูกแบ่ง ในสมการข้างต้นเป็นค่าของ R ₂การเปลี่ยนแปลงวี_ออกเครื่องชั่งน้ำหนักตามที่เกี่ยวกับแรงดันไฟฟ้าอินพุต V ใน

โดยปกติโพเทนชิออมิเตอร์เป็นตัวแบ่งศักย์ซึ่งสามารถปรับขนาดแรงดันไฟฟ้าขาออกของวงจรตามค่าของตัวต้านทานตัวแปรซึ่งปรับขนาดโดยใช้ลูกบิด มีสามพิน: GND, Signal และ + 5V ดังแสดงในแผนภาพด้านล่าง -

ผลลัพธ์

เมื่อเปลี่ยนตำแหน่ง NOP ของหม้อเซอร์โวมอเตอร์จะเปลี่ยนมุม

Stepper Motor หรือสเต็ปมอเตอร์คือมอเตอร์ซิงโครนัสแบบไม่มีแปรงซึ่งแบ่งการหมุนเต็มออกเป็นหลายขั้นตอน ไม่เหมือนกับมอเตอร์กระแสตรงไร้แปรงถ่านซึ่งจะหมุนอย่างต่อเนื่องเมื่อใช้แรงดันไฟฟ้ากระแสตรงคงที่มอเตอร์แบบสเต็ปจะหมุนในมุมขั้นตอนที่ไม่ต่อเนื่อง

Stepper Motors จึงได้รับการผลิตขึ้นโดยมีขั้นตอนต่อการหมุนรอบ 12, 24, 72, 144, 180 และ 200 ทำให้ได้มุมการก้าวที่ 30, 15, 5, 2.5, 2 และ 1.8 องศาต่อก้าว มอเตอร์สเต็ปสามารถควบคุมได้โดยมีหรือไม่มีข้อเสนอแนะ

ลองนึกภาพมอเตอร์บนเครื่องบิน RC มอเตอร์หมุนเร็วมากในทิศทางเดียวหรืออีกทิศทางหนึ่ง คุณสามารถเปลี่ยนความเร็วตามปริมาณพลังงานที่ให้กับมอเตอร์ได้ แต่คุณไม่สามารถบอกให้ใบพัดหยุดที่ตำแหน่งใดตำแหน่งหนึ่งได้

ลองนึกภาพเครื่องพิมพ์ ภายในเครื่องพิมพ์มีชิ้นส่วนที่เคลื่อนไหวได้มากมายรวมทั้งมอเตอร์ด้วย มอเตอร์ตัวหนึ่งทำหน้าที่เป็นตัวป้อนกระดาษลูกกลิ้งหมุนที่เคลื่อนย้ายกระดาษขณะที่กำลังพิมพ์หมึกอยู่ มอเตอร์นี้ต้องสามารถเคลื่อนกระดาษได้ในระยะที่แน่นอนเพื่อให้สามารถพิมพ์ข้อความบรรทัดถัดไปหรือบรรทัดถัดไปของรูปภาพได้

มีมอเตอร์อีกตัวหนึ่งติดอยู่กับแกนเกลียวที่เลื่อนหัวพิมพ์ไปมา อีกครั้งแกนเกลียวนั้นจะต้องมีการเคลื่อนย้ายจำนวนที่แน่นอนเพื่อพิมพ์ทีละตัวอักษร นี่คือจุดที่สเต็ปเปอร์มอเตอร์มีประโยชน์

Stepper Motor ทำงานอย่างไร

มอเตอร์กระแสตรงปกติจะหมุนไปในทิศทางเดียวในขณะที่มอเตอร์ Stepper สามารถหมุนได้ทีละน้อยอย่างแม่นยำ

สเต็ปเปอร์มอเตอร์สามารถหมุนองศา (หรือขั้นตอน) ได้ตามต้องการ สิ่งนี้ช่วยให้คุณสามารถควบคุมมอเตอร์ได้อย่างสมบูรณ์ทำให้คุณสามารถเคลื่อนย้ายไปยังตำแหน่งที่แน่นอนและดำรงตำแหน่งนั้นได้ ทำได้โดยการเปิดขดลวดภายในมอเตอร์เป็นระยะเวลาสั้น ๆ ข้อเสียคือคุณต้องจ่ายไฟให้มอเตอร์ตลอดเวลาเพื่อให้อยู่ในตำแหน่งที่คุณต้องการ

สิ่งที่คุณต้องรู้ในตอนนี้ก็คือในการเคลื่อนสเต็ปเปอร์มอเตอร์คุณต้องบอกให้มันเลื่อนขั้นตอนจำนวนหนึ่งไปในทิศทางเดียวหรืออีกทิศทางหนึ่งและบอกความเร็วที่จะก้าวไปในทิศทางนั้น มีสเต็ปเปอร์มอเตอร์หลายแบบ วิธีการที่อธิบายไว้ที่นี่สามารถใช้เพื่อสรุปวิธีการใช้มอเตอร์และไดรเวอร์อื่น ๆ ที่ไม่ได้กล่าวถึงในบทช่วยสอนนี้ อย่างไรก็ตามขอแนะนำให้คุณศึกษาเอกสารข้อมูลและคำแนะนำของมอเตอร์และไดรเวอร์เฉพาะสำหรับรุ่นที่คุณมีอยู่เสมอ

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 ×บอร์ด Arduino UNO
• 1 ×มอเตอร์ไบโพลาร์ขนาดเล็กตามที่แสดงในภาพด้านล่าง
• 1 × LM298 IC ขับรถ

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อตามที่แสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

รหัส Arduino

/* Stepper Motor Control */

#include <Stepper.h>
const int stepsPerRevolution = 90;
// change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
   // set the speed at 60 rpm:
   myStepper.setSpeed(5);
   // initialize the serial port:
   Serial.begin(9600);
}

void loop() {
   // step one revolution in one direction:
   Serial.println("clockwise");
   myStepper.step(stepsPerRevolution);
   delay(500);
   // step one revolution in the other direction:
   Serial.println("counterclockwise");
   myStepper.step(-stepsPerRevolution);
   delay(500);
}

รหัสที่ควรทราบ

โปรแกรมนี้ขับเคลื่อนมอเตอร์แบบ unipolar หรือ bipolar stepper มอเตอร์ติดอยู่กับพินดิจิทัล 8 - 11 ของ Arduino

ผลลัพธ์

มอเตอร์จะทำการปฏิวัติหนึ่งครั้งในทิศทางเดียวจากนั้นจึงหมุนไปอีกทิศทางหนึ่ง

ในบทนี้เราจะใช้ Arduino Tone Library ไม่มีอะไรนอกจาก Arduino Library ซึ่งสร้างคลื่นสี่เหลี่ยมของความถี่ที่ระบุ (และรอบการทำงาน 50%) บนขา Arduino ใด ๆ สามารถระบุระยะเวลาเป็นทางเลือกมิฉะนั้น wave จะดำเนินต่อไปจนกว่าจะมีการเรียกใช้ฟังก์ชัน stop () พินสามารถเชื่อมต่อกับกริ่งแบบเพียโซหรือลำโพงเพื่อเล่นโทนเสียง

Warning- อย่าเชื่อมต่อพินโดยตรงกับอินพุตเสียงใด ๆ แรงดันไฟฟ้าสูงกว่าแรงดันไฟฟ้าระดับสายมาตรฐานมากและอาจทำให้อินพุตการ์ดเสียงเสียหายได้เป็นต้นคุณสามารถใช้ตัวแบ่งแรงดันไฟฟ้าเพื่อลดแรงดันไฟฟ้าได้

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• ลำโพง 1 × 8 โอห์ม
• ตัวต้านทาน 1 × 1k
• 1 ×บอร์ด Arduino UNO

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อตามที่แสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

ในการสร้างไฟล์ pitches.h ให้คลิกปุ่มใต้ไอคอนมอนิเตอร์แบบอนุกรมแล้วเลือก "แท็บใหม่" หรือใช้ Ctrl + Shift + N

จากนั้นวางรหัสต่อไปนี้ -

/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

บันทึกรหัสที่ระบุข้างต้นเป็น pitches.h

รหัส Arduino

#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_GS3, NOTE_G3,0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {
   4, 8, 8, 4,4,4,4,4 
};

void setup() {
   // iterate over the notes of the melody:
   for (int thisNote = 0; thisNote < 8; thisNote++) {
      // to calculate the note duration, take one second
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000/noteDurations[thisNote];
      tone(8, melody[thisNote],noteDuration);
      //pause for the note's duration plus 30 ms:
      delay(noteDuration +30);
   }
}

void loop() {
   // no need to repeat the melody.
}

รหัสที่ควรทราบ

รหัสใช้ไฟล์พิเศษ pitches.h ไฟล์นี้มีค่าระดับเสียงทั้งหมดสำหรับโน้ตทั่วไป ตัวอย่างเช่น NOTE_C4 อยู่ตรงกลาง C NOTE_FS4 คือ F sharp และอื่น ๆ ตารางบันทึกย่อนี้เขียนขึ้นโดย Brett Hagman ซึ่งใช้คำสั่ง tone () คุณอาจพบว่ามีประโยชน์เมื่อใดก็ตามที่คุณต้องการทำโน้ตดนตรี

ผลลัพธ์

คุณจะได้ยินโน้ตดนตรีที่บันทึกไว้ในสนาม h. ไฟล์.

โมดูลตัวส่งและตัวรับสัญญาณไร้สายทำงานที่ 315 Mhz พวกเขาสามารถใส่ลงในเขียงหั่นขนมและทำงานร่วมกับไมโครคอนโทรลเลอร์ได้ดีเพื่อสร้างลิงค์ข้อมูลไร้สายที่เรียบง่าย ด้วยเครื่องส่งและตัวรับหนึ่งคู่โมดูลจะทำงานสื่อสารข้อมูลทางเดียวเท่านั้นอย่างไรก็ตามคุณจะต้องมีคู่สองคู่ (ที่มีความถี่ต่างกัน) เพื่อทำหน้าที่เป็นคู่เครื่องส่ง / เครื่องรับ

Note- โมดูลเหล่านี้ไม่เลือกปฏิบัติและได้รับเสียงรบกวนในระดับที่เหมาะสม ทั้งเครื่องส่งและเครื่องรับทำงานที่ความถี่ทั่วไปและไม่มี ID

ข้อกำหนดโมดูลตัวรับ

• รุ่นผลิตภัณฑ์ - MX-05V
• แรงดันไฟฟ้าที่ใช้งาน - DC5V
• กระแสไฟฟ้าดับ - 4mA
• ความถี่รับ - 315Mhz
• ความไวของตัวรับ - -105DB
• ขนาด - 30 * 14 * 7 มม

ข้อกำหนดโมดูลเครื่องส่งสัญญาณ

• รุ่นสินค้า - MX-FS-03V
• ระยะเริ่มต้น - 20-200 เมตร (แรงดันไฟฟ้าต่างกันผลลัพธ์ที่แตกต่างกัน)
• แรงดันไฟฟ้า - 3.5-12V
• ขนาด - 19 * 19 มม
• โหมดการทำงาน - AM
• อัตราการถ่ายโอน - 4KB / S
• กำลังส่ง - 10mW
• ความถี่ในการส่ง - 315Mhz
• เสาอากาศภายนอก - สายมัลติคอร์ธรรมดาหรือสายเดี่ยว 25 ซม
• Pinout จากซ้าย→ขวา - (DATA; V _CC ; GND)

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 2 × Arduino UNO บอร์ด
• เครื่องส่งสัญญาณลิงค์ 1 × Rf
• 1 ×ตัวรับลิงค์ Rf

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อตามที่แสดงในภาพด้านล่าง

ร่าง

เปิดซอฟต์แวร์ Arduino IDE บนคอมพิวเตอร์ของคุณ การเข้ารหัสในภาษา Arduino จะควบคุมวงจรของคุณ เปิดไฟล์ร่างใหม่โดยคลิกใหม่

Note- คุณต้องรวมไลบรารีปุ่มกดในไฟล์ไลบรารี Arduino ของคุณ คัดลอกและวางไฟล์ VirtualWire.lib ในโฟลเดอร์ไลบรารีตามที่ไฮไลต์ในภาพหน้าจอด้านล่าง

รหัส Arduino สำหรับเครื่องส่งสัญญาณ

//simple Tx on pin D12
#include <VirtualWire.h>
char *controller;

void setup() {
   pinMode(13,OUTPUT);
   vw_set_ptt_inverted(true);
   vw_set_tx_pin(12);
   vw_setup(4000);// speed of data transfer Kbps
}

void loop() {
   controller="1" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,1);
   delay(2000);
   controller="0" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,0);
   delay(2000);
}

รหัสที่ควรทราบ

นี่เป็นรหัสง่ายๆ ขั้นแรกมันจะส่งอักขระ '1' และหลังจากนั้นสองวินาทีมันจะส่งอักขระ '0' ไปเรื่อย ๆ

รหัส Arduino สำหรับตัวรับ

//simple Rx on pin D12
#include <VirtualWire.h>

void setup() {
   vw_set_ptt_inverted(true); // Required for DR3100
   vw_set_rx_pin(12);
   vw_setup(4000); // Bits per sec
   pinMode(5, OUTPUT);
   vw_rx_start(); // Start the receiver PLL running
}

void loop() {
   uint8_t buf[VW_MAX_MESSAGE_LEN];
   uint8_t buflen = VW_MAX_MESSAGE_LEN;
   if (vw_get_message(buf, &buflen)) // Non-blocking {
      if(buf[0]=='1') {
         digitalWrite(5,1);
      }
      if(buf[0]=='0') {
         digitalWrite(5,0);
      }
   }
}

รหัสที่ควรทราบ

LED ที่เชื่อมต่อกับพินหมายเลข 5 บนบอร์ด Arduino จะเปิดเมื่อได้รับอักขระ '1' และปิดเมื่อได้รับอักขระ '0'

โมดูล CC3000 WiFi จาก Texas Instruments เป็นแพ็คเกจสีเงินขนาดเล็กซึ่งในที่สุดก็นำฟังก์ชัน WiFi ที่ใช้งานง่ายและราคาไม่แพงมาสู่โครงการ Arduino ของคุณ

ใช้ SPI สำหรับการสื่อสาร (ไม่ใช่ UART!) เพื่อให้คุณสามารถส่งข้อมูลได้เร็วเท่าที่คุณต้องการหรือช้าเท่าที่คุณต้องการ มีระบบขัดจังหวะที่เหมาะสมพร้อมขา IRQ เพื่อให้คุณสามารถเชื่อมต่อแบบอะซิงโครนัสได้ รองรับ 802.11b / g, open / WEP / WPA / WPA2 security, TKIP & AES สแต็ก TCP / IP ในตัวพร้อมอินเทอร์เฟซ "ซ็อกเก็ต BSD" รองรับ TCP และ UDP ทั้งในไคลเอนต์และโหมดเซิร์ฟเวอร์

ส่วนประกอบที่จำเป็น

คุณจะต้องมีส่วนประกอบต่อไปนี้ -

• 1 × Arduino Uno
• 1 × Adafruit CC3000 คณะกรรมการฝ่าวงล้อม
• รีเลย์ 1 × 5V
• 1 × Rectifier ไดโอด
• 1 × LED
• ตัวต้านทาน 1 × 220 โอห์ม
• 1 × Breadboard และสายจัมเปอร์

สำหรับโครงการนี้คุณต้องมี Arduino IDE ตามปกติไลบรารี CC3000 ของ Adafruit และไลบรารี CC3000 MDNS เราจะใช้ไลบรารี aREST เพื่อส่งคำสั่งไปยังรีเลย์ผ่าน WiFi

ขั้นตอน

ทำตามแผนภาพวงจรและทำการเชื่อมต่อตามที่แสดงในภาพด้านล่าง

การกำหนดค่าฮาร์ดแวร์สำหรับโครงการนี้ทำได้ง่ายมาก

• เชื่อมต่อขา IRQ ของบอร์ด CC3000 กับหมายเลข 3 ของบอร์ด Arduino
• VBAT ถึงพิน 5 และ CS เพื่อตรึง 10
• เชื่อมต่อพิน SPI กับบอร์ด Arduino: MOSI, MISO และ CLK กับพิน 11, 12 และ 13 ตามลำดับ
• V _inเชื่อมต่อกับ Arduino 5V และ GND ถึง GND

ตอนนี้ให้เราเชื่อมต่อรีเลย์

หลังจากวางรีเลย์บนเขียงหั่นขนมคุณสามารถเริ่มระบุส่วนสำคัญสองส่วนบนรีเลย์ของคุณ: ส่วนขดลวดที่สั่งการรีเลย์และส่วนสวิตช์ที่เราจะติด LED

• ขั้นแรกให้เชื่อมต่อพินหมายเลข 8 ของบอร์ด Arduino กับขาหนึ่งของขดลวด
• เชื่อมต่อพินอื่น ๆ เข้ากับกราวด์ของบอร์ด Arduino

คุณต้องวางไดโอดเรียงกระแส (ขั้วบวกที่เชื่อมต่อกับขากราวด์) ไว้เหนือพินของขดลวดเพื่อป้องกันวงจรของคุณเมื่อรีเลย์กำลังเปลี่ยน

• เชื่อมต่อบอร์ด Arduino + 5V เข้ากับพินทั่วไปของสวิตช์รีเลย์

• ในที่สุดเชื่อมต่อพินอื่น ๆ ของสวิตช์ (โดยปกติจะเป็นพินที่ไม่ได้เชื่อมต่อเมื่อรีเลย์ปิดอยู่) เข้ากับ LED ในชุดที่มีตัวต้านทาน 220 โอห์มและเชื่อมต่ออีกด้านของ LED เข้ากับกราวด์ของ Arduino คณะกรรมการ.

การทดสอบส่วนประกอบส่วนบุคคล

คุณสามารถทดสอบรีเลย์ด้วยภาพร่างต่อไปนี้ -

const int relay_pin = 8; // Relay pin

void setup() {
   Serial.begin(9600);
   pinMode(relay_pin,OUTPUT);
}

void loop() {
   // Activate relay
   digitalWrite(relay_pin, HIGH);
   // Wait for 1 second
   delay(1000);
   // Deactivate relay
   digitalWrite(relay_pin, LOW);
   // Wait for 1 second
   delay(1000);
}

รหัสที่ควรทราบ

รหัสนี้อธิบายได้เอง คุณสามารถอัปโหลดไปยังบอร์ดและรีเลย์จะเปลี่ยนสถานะทุกวินาทีและ LED จะเปิดและปิดตามนั้น

การเพิ่มการเชื่อมต่อ WiFi

ตอนนี้ให้เราควบคุมรีเลย์แบบไร้สายโดยใช้ชิป CC3000 WiFi ซอฟต์แวร์สำหรับโครงการนี้ใช้โปรโตคอล TCP อย่างไรก็ตามสำหรับโครงการนี้บอร์ด Arduino จะทำงานบนเว็บเซิร์ฟเวอร์ขนาดเล็กดังนั้นเราจึงสามารถ“ ฟัง” คำสั่งที่มาจากคอมพิวเตอร์ได้ ก่อนอื่นเราจะดูแลร่าง Arduino จากนั้นเราจะดูวิธีเขียนโค้ดฝั่งเซิร์ฟเวอร์และสร้างอินเทอร์เฟซที่ดี

ก่อนอื่นร่าง Arduino เป้าหมายคือการเชื่อมต่อกับเครือข่าย WiFi ของคุณสร้างเว็บเซิร์ฟเวอร์ตรวจสอบว่ามีการเชื่อมต่อ TCP ขาเข้าหรือไม่จากนั้นเปลี่ยนสถานะของรีเลย์ตามนั้น

ส่วนสำคัญของจรรยาบรรณ

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

คุณต้องกำหนดภายในรหัสที่เฉพาะเจาะจงสำหรับการกำหนดค่าของคุณเช่นชื่อ Wi-Fi และรหัสผ่านและพอร์ตสำหรับการสื่อสาร TCP (เราใช้ 80 ที่นี่)

// WiFi network (change with your settings!)
   #define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters!
   #define WLAN_PASS "yourPassword"
   #define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, 
   // WLAN_SEC_WPA or WLAN_SEC_WPA2

// The port to listen for incoming TCP connections
   #define LISTEN_PORT 80

จากนั้นเราสามารถสร้างอินสแตนซ์ CC3000 เซิร์ฟเวอร์และอินสแตนซ์ aREST -

// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();

ในส่วนการตั้งค่า () ของร่างตอนนี้เราสามารถเชื่อมต่อชิป CC3000 กับเครือข่ายได้แล้ว -

cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

คอมพิวเตอร์จะรู้ได้อย่างไรว่าจะส่งข้อมูลไปที่ใด วิธีหนึ่งคือเรียกใช้ร่างครั้งเดียวจากนั้นรับที่อยู่ IP ของบอร์ด CC3000 และแก้ไขรหัสเซิร์ฟเวอร์อีกครั้ง อย่างไรก็ตามเราสามารถทำได้ดีขึ้นและนั่นคือจุดที่ไลบรารี CC3000 MDNS เข้ามามีบทบาท เราจะกำหนดชื่อตายตัวให้กับบอร์ด CC3000 ของเราด้วยไลบรารีนี้ดังนั้นเราจึงสามารถจดชื่อนี้ลงในรหัสเซิร์ฟเวอร์ได้โดยตรง

สิ่งนี้ทำได้โดยใช้รหัสต่อไปนี้ -

if (!mdns.begin("arduino", cc3000)) {
   while(1);
}

เราต้องฟังการเชื่อมต่อที่เข้ามาด้วย

restServer.begin();

ต่อไปเราจะเขียนโค้ดฟังก์ชัน loop () ของร่างที่จะดำเนินการอย่างต่อเนื่อง ก่อนอื่นเราต้องอัปเดตเซิร์ฟเวอร์ mDNS

mdns.update();

เซิร์ฟเวอร์ที่ทำงานบนบอร์ด Arduino จะรอการเชื่อมต่อขาเข้าและจัดการคำขอ

Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

ตอนนี้ค่อนข้างง่ายในการทดสอบโครงการผ่าน WiFi ตรวจสอบให้แน่ใจว่าคุณอัปเดตร่างด้วยชื่อและรหัสผ่าน WiFi ของคุณเองแล้วอัปโหลดร่างไปยังบอร์ด Arduino ของคุณ เปิดจอภาพอนุกรม Arduino IDE ของคุณแล้วมองหาที่อยู่ IP ของบอร์ดของคุณ

สมมติว่าส่วนที่เหลือนี่คือ 192.168.1.103

จากนั้นไปที่เว็บเบราว์เซอร์ที่คุณชื่นชอบและพิมพ์ -

192.168.1.103/digital/8/1

คุณจะเห็นว่ารีเลย์ของคุณเปิดโดยอัตโนมัติ

การสร้างอินเทอร์เฟซรีเลย์

ตอนนี้เราจะเขียนโค้ดอินเทอร์เฟซของโครงการ จะมีสองส่วนที่นี่: ไฟล์ HTML ที่มีอินเทอร์เฟซและไฟล์ Javascript ฝั่งไคลเอ็นต์เพื่อจัดการกับการคลิกบนอินเทอร์เฟซ อินเทอร์เฟซที่นี่ขึ้นอยู่กับไฟล์aREST.js โครงการซึ่งสร้างขึ้นเพื่อควบคุมอุปกรณ์ WiFi จากคอมพิวเตอร์ของคุณได้อย่างง่ายดาย

ก่อนอื่นให้เราดูไฟล์ HTML ที่เรียกว่า interface.html ส่วนแรกประกอบด้วยการนำเข้าไลบรารีที่จำเป็นทั้งหมดสำหรับอินเทอร์เฟซ -

<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/css" 
      href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
   <link rel="stylesheet" type = "text/css" href = "style.css">
   <script type = "text/javascript" 
      src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script>
   <script type = "text/javascript" 
      src = "script.js"></script>
</head>

จากนั้นเรากำหนดปุ่มสองปุ่มภายในอินเทอร์เฟซปุ่มหนึ่งเพื่อเปิดรีเลย์และอีกปุ่มหนึ่งเพื่อปิดอีกครั้ง

<div class = 'container'>
   <h1>Relay Control</h1>
   <div class = 'row'>
      <div class = "col-md-1">Relay</div>
      <div class = "col-md-2">
         <button id = 'on' class = 'btn btn-block btn-success'>On</button>
      </div>
      <div class = "col-md-2">
         <button id = 'off' class = 'btn btn-block btn-danger'>On</button>
      </div>
   </div>
</div>

ตอนนี้เรายังต้องการไฟล์ Javascript ฝั่งไคลเอ็นต์เพื่อจัดการกับการคลิกปุ่มต่างๆ นอกจากนี้เรายังจะสร้างอุปกรณ์ที่เราจะเชื่อมโยงกับชื่อ mDNS ของอุปกรณ์ Arduino ของเรา หากคุณเปลี่ยนสิ่งนี้ในรหัส Arduino คุณจะต้องแก้ไขที่นี่เช่นกัน

// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

รหัสที่สมบูรณ์สำหรับโครงการนี้สามารถพบได้ในไฟล์ GitHubที่เก็บ เข้าไปในโฟลเดอร์อินเทอร์เฟซและเปิดไฟล์ HTML ด้วยเบราว์เซอร์ที่คุณชื่นชอบ คุณควรเห็นสิ่งที่คล้ายกันในเบราว์เซอร์ของคุณ -

ลองคลิกปุ่มบนเว็บอินเตอร์เฟส ควรเปลี่ยนสถานะของรีเลย์เกือบจะในทันที

หากคุณจัดการให้มันใช้งานได้ไชโย! คุณเพิ่งสร้างสวิตช์ไฟที่ควบคุมด้วย Wi-Fi แน่นอนว่าคุณสามารถควบคุมได้มากกว่าแสงด้วยโครงการนี้ ตรวจสอบให้แน่ใจว่ารีเลย์ของคุณรองรับพลังงานที่จำเป็นสำหรับอุปกรณ์ที่คุณต้องการควบคุมและคุณก็พร้อมใช้งาน