ค้นหาบทความที่นี่

บทความทั้งหมด

[Tips] การสร้างฟังก์ชั่นไว้เรียกใช้งานซ้ำ

3 ปีที่ผ่านมา

โดย เจ้าของร้าน

Publish : 29 July 2022

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

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

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

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

สร้างฟังก์ชันขึ้นมาใช้งาน
ก่อนอื่น "Programming Function" คืออะไร? นั่นสิ ปกติผู้เขียนก็เรียกฟังก์ชัน ๆ ตลอด ก็รู้ว่ามันคือไอ้เนี่ย ก้อนของโค้ดโปรแกรมก้อนนึงที่เอาไว้เรียกขึ้นมาทำงาน แล้วจริง ๆ มันต้องอธิบายไอ้เจ้าก้อนนี้ว่าอะไร? เลยลองไปค้นดูก็เจอเว็บไซต์ของเมืองนอกเขาให้คำเปรียบเทียบไว้ดีมากครับ ขอยกมาเลย "ฟังก์ชันของโปรแกรม ก็เหมือนเครื่องจักร โค้ดของเราทั้งหมดก็เหมือนโรงงาน ในโรงงานก็จะมีเครื่องจักรต่าง ๆ อันนี้เครื่องพิมพ์ อันนี้เครื่องห่อ อันนี้เครื่องตัด แล้วประกอบรวมกันทำงานจนได้ผลผลิตออกมา" โห แบบนี้เห็นภาพชัดเจนเลยมั๊ยครับ
เอาหล่ะ เมื่อพอมองภาพออกเรามาทดลองสร้างฟังก์ชันใช้งานกันดู

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

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

จากโปรแกรมนี้ เรากำหนดในวงเล็บของฟังก์ชันให้มีตัวแปร Integer ชื่อว่า TIMES และไปเรียกใช้งานในฟังก์ชันว่าคำสั่ง for จะทำงานเป็น TIMES รอบ เพียงเท่านี้ก็เรียบร้อย กลับไปดูใน loop เราใส่ 2 ไว้ใน BLINK ครั้งแรก และ 3 ใน BLINK ครั้งที่สอง นั่นคือในครั้งแรกตัวแปร TIMES ในฟังก์ชัน BLINK ก็จะมีค่าเป็น 2 for ในฟังก์ชันก็จะทำงาน 2 รอบ เป็นผลให้ไฟกระพริบ 2 ครั้ง และใน BLINK ครั้งที่สองเราใส่ 3 TIMES ใน BLINK มีค่าเป็น 3 for ก็จะทำงาน 3 รอบ ทำให้ไฟกระพริบ 3 ครั้ง ง่าย ๆ ใช่มั๊ยครับ ทีนี้จะกระพริบทีเดียวหรือกระพริบล้านทีก็ทำงานได้ด้วยฟังก์ชันอันเดียวกันเลย

ทีนี้ถ้าเราต้องการให้มีหลาย ๆ ตัวแปรเข้าไปหล่ะ ก็ไม่ยากอะไรครับ เราสามารถใส่ตัวแปรเพิ่มเข้าไปได้เลยโดยใช้วิธีเดียวกันนี่แหละ แค่คั่นด้วยเครื่องหมาย ' , ' เท่านี้เอง เวลาจะเรียกใช้ก็นำค่าใส่เรียงไปตามลำดับให้ถูกต้องก็แค่นั้นเองครับ
ตัวอย่างต่อไปนี้ จะขอให้อ่านค่าจาก A0 และ A1 ที่ปล่อยลอยไว้ไม่ต้องต่อกับอะไร เราจะได้ค่าที่เป็นเลขสุ่มขึ้นมา จากนั้นเราจะเอาค่าที่อ่านได้จาก A0 มาลบด้วยค่าที่อ่านได้จาก A1 แล้วแสดงผลทาง Serial Monitor

ลองดูผลลัพธ์ที่ Serial Monitor กันครับ

และต่อด้วยคำถามว่า ถ้าเราเขียนโค้ดเป็น CALCULATE(A1_VAL, A0_VAL); หล่ะครับ? คงตอบกันได้เลยทันทีเนอะ

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

โปรแกรมเดิม อ่านค่า A0 และ A1 นำไปลบค่ากันในฟังก์ชัน แต่เรามีการส่งค่า RESULT เป็นตัวแปร int จากฟังก์ชัน CALCULATE ออกมาเก็บไว้ในตัวแปร CAL_RESULT ใน loop แล้วจึงนำค่า CAL_RESULT ที่ถูกส่งออกมาเนี่ยไปบวกกับ 10 อีกทีนึง

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

จากนั้นทำการตั้งชื่อแท็ปแล้วกด OK

เพียงเท่านี้ก็จะมีแท็ปใหม่เพิ่มขึ้นมาแล้ว และถ้าไปดูที่โฟลเดอร์ของโปรเจคก็จะมีไฟล์ .ino เพิ่มขึ้นมา

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

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