Arduino Datalogger: 8 ขั้นตอน (พร้อมรูปภาพ)

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:06

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

ที่จะเริ่มต้น:

คุณจะต้องมีบัญชี Tinkercad (www.tinkercad.com) ตรงไปและลงทะเบียนด้วยอีเมลหรือบัญชีโซเชียลมีเดียของคุณ

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

คุณสามารถค้นหาไฟล์ทั้งหมดได้ที่ TInkercad Circuits - ขอบคุณสำหรับการตรวจสอบ!

ขั้นตอนที่ 1: เพิ่มส่วนประกอบบางอย่าง

คุณจะต้องมีส่วนประกอบพื้นฐานบางอย่าง ซึ่งรวมถึง:

• บอร์ด Arduino
• เขียงหั่นขนม

เพิ่มโดยค้นหาและคลิกลากไปยังพื้นที่ตรงกลาง

วางเขียงหั่นขนมไว้เหนือ Arduino ทำให้ง่ายต่อการดูการเชื่อมต่อในภายหลัง

ขั้นตอนที่ 2: หมายเหตุเกี่ยวกับ Breadboards

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

1. จุดเชื่อมต่อในแนวตั้ง แต่เส้นตรงกลางแยกการเชื่อมต่อนี้ออกจากคอลัมน์ด้านบนและด้านล่าง
2. คอลัมน์ไม่ได้เชื่อมต่อจากซ้ายไปขวาเหมือนข้ามแถว ซึ่งหมายความว่าส่วนประกอบทั้งหมดควรเชื่อมต่อข้ามคอลัมน์แทนที่จะเชื่อมต่อในแนวตั้ง
3. หากคุณต้องการใช้ปุ่มหรือสวิตช์ ให้เชื่อมต่อผ่านช่องตรงกลาง เราจะเยี่ยมชมสิ่งนี้ในบทช่วยสอนในภายหลัง

ขั้นตอนที่ 3: เพิ่มเซ็นเซอร์สองตัว

เซ็นเซอร์สองตัวที่เราใช้คือเซ็นเซอร์ไวแสงและเซ็นเซอร์อุณหภูมิ

เซ็นเซอร์เหล่านี้ประเมินแสงและอุณหภูมิ เราใช้ Arduino เพื่ออ่านค่าและแสดงผลในจอภาพแบบอนุกรมบน Arduino

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

ขั้นตอนที่ 4: เซ็นเซอร์ไวแสง

1. สำหรับเซ็นเซอร์ไวแสง ให้เพิ่มสายไฟจากพิน 5V บน Arduino ไปที่คอลัมน์เดียวกับขาขวาของชิ้นส่วนในเขียงหั่นขนม เปลี่ยนสีลวดเป็นสีแดง
2. เชื่อมต่อขาซ้ายผ่านพินในคอลัมน์เดียวกันกับพิน A0 (A-zero) บน Arduino นี่คือขาอะนาล็อกที่เราจะใช้อ่านค่าจากเซ็นเซอร์ ระบายสีลวดนี้ให้เป็นสีเหลืองหรืออย่างอื่นที่ไม่ใช่สีแดงหรือสีดำ

3. วางตัวต้านทาน (ค้นหาและคลิก-ลาก) บนบอร์ด ทำให้วงจรสมบูรณ์และปกป้องเซ็นเซอร์และพิน

   • หมุนไปรอบ ๆ เพื่อให้ข้ามคอลัมน์
   • ต่อขาข้างหนึ่งเข้ากับเสาขาขวาบนเขียงหั่นขนม

   • วางลวดจากปลายอีกด้านของตัวต้านทานลงกราวด์

     เปลี่ยนสีลวดเป็นสีดำ

4. ตรวจสอบการเชื่อมต่อทั้งหมดอีกครั้ง หากมีบางอย่างไม่ถูกต้อง การทำงานนี้จะไม่ถูกต้อง

ขั้นตอนที่ 5: เริ่มรหัส

ลองดูรหัสสำหรับส่วนประกอบนี้

ขั้นแรก ดูภาพที่สามในขั้นตอนนี้ มันมีรหัสบางอย่างที่มีสองฟังก์ชั่น:

การตั้งค่าเป็นโมฆะ ()

วงเป็นโมฆะ ()

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

ฟังก์ชันการตั้งค่าจะทำงานเพียงครั้งเดียวเมื่อ Arduino บูท (เมื่อคุณเสียบปลั๊กหรือใส่แบตเตอรี่)

ฟังก์ชันวนรอบทำงานในลูปคงที่ตั้งแต่มิลลิวินาทีที่ฟังก์ชันการตั้งค่าเสร็จสิ้น

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

งาน

เปิดแผงรหัสด้วยปุ่มใน Tinkercad เปลี่ยนดรอปดาวน์ของ Blocks เป็น Text ยอมรับกล่องคำเตือนที่ปรากฏขึ้น ตอนนี้ ลบทุกอย่างที่คุณเห็น ยกเว้นข้อความในรูปภาพที่สามในขั้นตอนนี้

ตัวแปร

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

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

int someVar = A0;

ดังนั้นเราจึงกำหนดตัวแปรและให้ประเภทเป็น int int เป็นจำนวนเต็มหรือจำนวนเต็ม

“แต่คุณไม่ได้ใช้จำนวนเต็ม!” ฉันได้ยินคุณพูด นั่นเป็นความจริง

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

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

รหัสของคุณควรมีลักษณะดังนี้:

int lightSensor = A0;

การตั้งค่าเป็นโมฆะ () { } วงเป็นโมฆะ () { }

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

int lightSensor = A0;

การตั้งค่าเป็นโมฆะ () { pinMode (lightSensor, INPUT); } วงเป็นโมฆะ () { }

ฟังก์ชัน pinMode บอก Arduino ว่าพิน (A0) จะถูกใช้เป็นพิน INPUT สังเกต camelCaseUsed (ดูแต่ละตัวอักษรตัวแรกเป็นตัวพิมพ์ใหญ่ เพราะมีโคน ดังนั้น… อูฐ…!) สำหรับตัวแปรและชื่อฟังก์ชัน นี่เป็นข้อตกลงและดีที่จะทำความคุ้นเคย

สุดท้าย ลองใช้ฟังก์ชัน analogRead เพื่อรับข้อมูล

int lightSensor = A0;

การตั้งค่าเป็นโมฆะ () { pinMode (lightSensor, INPUT); } วงเป็นโมฆะ () { int การอ่าน = analogRead (lightSensor); }

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

int lightSensor = A0;

การตั้งค่าเป็นโมฆะ () {// ตั้งค่าโหมดพิน pinMode (lightSensor, INPUT); // เพิ่มไลบรารีซีเรียล Serial.begin(9600); } วงเป็นโมฆะ () {// อ่านการอ่านค่า int ของเซ็นเซอร์ = analogRead (lightSensor); // พิมพ์ค่าไปยังจอภาพ Serial.print("Light: "); Serial.println (การอ่าน); // หน่วงเวลาลูปถัดไป 3 วินาที (3000); }

สิ่งใหม่บางอย่าง! ขั้นแรก คุณจะเห็นสิ่งเหล่านี้:

// นี่คือความคิดเห็น

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

ตอนนี้เราได้เพิ่ม Serial library ด้วย line

Serial.begin(9600)

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

สิ่งต่อไปที่เราทำคือพิมพ์ไปยังจอภาพแบบอนุกรม เราใช้สองฟังก์ชั่น:

// อันนี้พิมพ์ไปยังซีเรียลโดยไม่มีตัวแบ่งบรรทัด (การป้อนที่ส่วนท้าย)

Serial.print("แสง: "); // อันนี้ใส่ตัวแบ่งบรรทัด ดังนั้นทุกครั้งที่เราอ่านและเขียน มันจะขึ้นบรรทัดใหม่ Serial.println(reading);

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

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

ยอดเยี่ยม! เมื่อเราไป!

ขั้นตอนที่ 6: การจำลอง

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

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

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

ขั้นตอนที่ 7: ต่อสายเซ็นเซอร์อุณหภูมิ

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

ทีนี้มาอัพเดทโค้ดกัน

รหัสเซ็นเซอร์อุณหภูมิ

นี่เป็นเรื่องยุ่งยากเล็กน้อย แต่เพียงเพราะเราต้องทำคณิตศาสตร์เพื่อแปลงการอ่าน มันไม่เลวร้ายเกินไป

int lightSensor = A0;

int tempSensor = A1; การตั้งค่าเป็นโมฆะ () {// ตั้งค่าโหมดพิน pinMode (lightSensor, INPUT); // เพิ่มไลบรารีซีเรียล Serial.begin(9600); } void loop() { // ตัวตรวจจับอุณหภูมิ // การสร้างตัวแปรสองตัวในบรรทัดเดียว - โอ้ ประสิทธิภาพ! // Float var เพื่อเก็บแรงดันทศนิยม, องศาC; // อ่านค่าของพินและแปลงเป็นค่าที่อ่านได้ตั้งแต่ 0 - 5 // แรงดันพื้นฐาน = (5/1023 = 0.004882814); แรงดันไฟฟ้า = (analogRead (เซ็นเซอร์อุณหภูมิ) * 0.004882814); // แปลงเป็นองศา C องศาเซลเซียส = (แรงดัน - 0.5) * 100; // พิมพ์ไปยังจอภาพอนุกรม Serial.print("Temp: "); Serial.print(องศาC); Serial.println("oC"); // อ่านค่า int ของเซ็นเซอร์ = analogRead (lightSensor); // พิมพ์ค่าไปยังจอภาพ Serial.print("Light: "); Serial.println (การอ่าน); // หน่วงเวลาลูปถัดไป 3 วินาที (3000); }

ฉันได้อัปเดตโค้ดบางส่วนแล้ว ลองเดินผ่านพวกเขาทีละคน

ก่อนอื่นฉันเพิ่มบรรทัด

int tempSensor = A1;

เช่นเดียวกับ lightSensor ฉันต้องเก็บค่าไว้ในตัวแปรเพื่อให้ง่ายขึ้นในภายหลัง ถ้าฉันต้องเปลี่ยนตำแหน่งของเซ็นเซอร์นี้ (เช่น เดินสายบอร์ดใหม่) ฉันต้องเปลี่ยนโค้ดเพียงบรรทัดเดียว ไม่ต้องค้นหาทั่วทั้งโค้ดเบสเพื่อเปลี่ยน A0 หรือ A1 เป็นต้น

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

แรงดันลอย, องศาเซลเซียส;

สิ่งนี้มีประโยชน์จริง ๆ เพราะมันช่วยลดจำนวนบรรทัดที่ฉันต้องเขียนและเพิ่มความเร็วของโค้ด แม้ว่าจะหาข้อผิดพลาดได้ยากกว่า

ตอนนี้ เราจะอ่านและจัดเก็บ จากนั้นแปลงเป็นค่าเอาต์พุตของเรา

แรงดันไฟฟ้า = (analogRead (เซ็นเซอร์อุณหภูมิ) * 0.004882814);

องศาC = (แรงดัน - 0.5) * 100;

สองบรรทัดนั้นดูยาก แต่ในตอนแรก เราจะนำการอ่านและคูณมันด้วย 0.004… เพราะมันแปลง 1023 (การอ่านแบบอะนาล็อกคืนค่านี้) เป็นค่าที่อ่านได้จาก 5

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

ขั้นตอนที่ 8: การทดสอบและตรวจสอบ

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

คุณทำมันได้หรือไม่ แบ่งปันและบอกเล่าเรื่องราวของคุณ!

นี่คือวงจรสุดท้ายที่ฝังไว้สำหรับคุณ เพื่อให้คุณสามารถเล่น/ทดสอบการสร้างขั้นสุดท้ายได้ ขอบคุณสำหรับการกวดวิชา!