Posted on by — Leave a comment

Artificial Intelligent, Machine Learning, Deep Learning ต่างกันอย่างไร?

Artificial Intelligent (AI), Machine Learning (ML), Deep Learning (DL) เป็นคำที่ได้ยินกันบ่อย สื่อถึงความฉลาดของเครื่องจักร แต่มันต่างกันอย่างไรล่ะ ลองอ่านกันดูนะครับ

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

รูปที่ 1 แสดงถึง ML เป็นส่วนหนึ่งของ AI และ DL ก็เป็นส่วนหนึ่งของ ML

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

AI (Artificial Intelligent) คืออะไร

ถ้าแปลกันตรงตัวก็คือ “ปัญญาประดิษฐ์” นั่นเอง ปัญญาประดิษฐ์เป็นแนวคิดกว้าง ๆ ว่า เป็นคอมพิวเตอร์ หรือหุ่นยนต์ หรือเครื่องจักร สามารถแสดงการแก้ไขปัญหาได้เหมือนมนุษย์ ซึ่งต้องเน้นว่า เป็นการ “แสดง” ออกที่เหมือนมนุษย์ ไม่ใช่ “คิด” ได้เหมือนมนุษย์ โดยที่มีหลายเทคนิคที่ทำให้ เครื่องจักรสามารถแสดงออก หรือแก้ปัญหาได้ เหมือนหรือคล้ายมนุษย์ เช่น rule-based system หรือ expert system ซึ่งเป็นการที่โปรแกรมเมอร์ เขียนโปรแกรมกำหนดไว้หมดแล้วว่า เงื่อนไขแบบไหน หรือสถานการณ์ไหน ต้องเลือกอะไร หรือทำอะไร

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

นอกจาก rule-based system แล้วยังมีเทคนิคอื่น ๆ ที่ช่วยให้เครื่องจักรแสดงออกถึงความฉลาดคล้ายมนุษย์ และเทคนิคหนึ่งที่สำคัญและพูดถึงก่อนบ่อยก็คือ machine learning นั่นเอง

Machine Learning (ML) คืออะไร

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

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

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

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

รูปที่ 2 แสดงความสัมพันธ์ของความเร็วลม และความสูงของคลื่น

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

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

y = ax + b ————– ( 1 )

  • x คือ ความเร็วลมชายฝั่ง
  • y คือ ค่าความสูงของคลื่นในทะเล
  • a และ b คือพารามิเตอร์ของโมเดล

เมื่อเราเลือกโมเดลทางคณิตศาสตร์มาแล้ว เราก็ต้องหาค่าพารามิเตอร์ a และ b เพื่อให้ได้สมาการเส้นตรงที่สมบูรณ์ ดังรูปที่ 3 

รูปที่ 3 แสดงถึงโมเดลทางคณิตศาสตร์ ที่แสดงถึงความสัมพันธ์ของข้อมูล

แต่ใครจะเป็นคนหาหาพารามิเตอร์นี้ล่ะ จากกราฟ การจะหาพารามิเตอร์ก็ไม่ยาก หาจุดตัดแกน x และ แกน y ก็น่าจะได้ประมาณว่า a น่าจะเป็น 0.5 และ b น่าจะเป็น 2 แต่ถ้าเราเป็นคนหาพารามิเตอร์ให้กับคอมพิวเตอร์ ก็เท่ากับว่านี่เป็นระบบ expert system คือเราหาให้ทุกอย่าง กำหนดทุกอย่าง เครื่องจักรไม่ต้องเรียนรู้อะไร เอาหละ เราจะไม่หาพารามิเตอร์ให้ แต่เราจะให้คอมพิวเตอร์หาพารามิเตอร์ที่เหมาะสมเอง โดยให้คอมพิวเตอร์เลือกค่าพารามิเตอร์เริ่มต้นออกมา เช่น a เป็น 1และ b เป็น -1 ก็จะได้กราฟเส้นตรงออกมาเป็นเส้นสีแดงดังรูปที่ 4 

รูปที่ 4 แสดงถึงโมเดลทางคณิตศาสตร์ที่มีพารามิเตอร์ยังไม่ดีพอ (สีแดง) และโมเดลเป้าหมายที่ต้องการ (สีเขียว)

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

ดังนั้น หน้าที่ของนักวิทยาศาสตร์ตอนนี้ก็คือ 

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

ส่วนเทคนิคในการเรียนรู้นั้นก็มีหลายแบบ ไม่ว่าจะเป็น decision tree, random forest, SVM และอื่น ๆ ส่วนตัวที่โดดเด่นและพูดถึงกันมาก (คงเดาได้ไม่ยาก) นั่นก็คือ Deep Learning นั่นเอง

Deep Learning คืออะไร

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

รูปที่ 5 แสดงถึงลักษณะของโมเดลคณิตศาสตร์ ที่แสดงลักษณะคล้าย neuron

จากรูปเป็นตัวอย่าง neuron ที่มี 3 input และมีพารามิเตอร์คือ 4 ตัว คือ w1, w2, w3 และ b และเราก็จะได้โมเดลคณิตศาสตร์เป็นสมาการที่ 2 ดังนี้

y = w1x1 + w2x2 + w3x3 + b ————– ( 2 )

นี่เป็นเพียงตัวอย่างหนึ่งเท่านั้น จะเห็นว่าก่อนหน้านี้ในสมาการที่ 1 มี input ตัวเดียว มีพารามิเตอร์ 2 ตัวคือ a และ b แต่ตอนนี้เริ่มซับซ้อนขึ้น คือมี input 3 ตัว และมีพารามิเตอร์ 4 ตัว

นอกจากนี้ ถ้านำ neuron หลาย ๆ ตัวมาเรียงกันเป็นแพ (layer) แล้วเอาแต่ละแพมาซ้อนกันเป็นชั้น ๆ ก็จะได้โมเดลคณิตศาสตร์ที่ซับซ้อนมากยิ่งขึ้น แล้วจะเห็นว่าข้อมูลมีการส่งต่อเพื่อประมวลผลต่อไปหลายชั้น ดังนั้นเราจึงเรียกโครงสร้างนี้ว่า Deep neural network และการใช้โครงสร้างนี้ในการเรียนรู้ ก็เรียกว่า deep learning นั่นเอง 

รูปที่ 6 แสดงถึงการเรียงตัวของ neuron ที่มีลักษณะเป็นชั้น ๆ หลาย ๆ ชั้นซ้อนกัน

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

หวังว่าผู้อ่านจะเห็นภาพในใจมากขึ้นนะครับ แล้วพบกันใหม่ ขอบคุณครับ

Posted on by — Leave a comment

Coupling กับ Decoupling capacitor คืออะไร?

คำว่า coupling ถ้าแปลกันตรง ๆ ก็คือ “การเชื่อมต่อ” และ decoupling ก็แปลกันง่าย ๆ ว่า “การไม่เชื่อมต่อ” แล้วมันเชื่อมต่อหรือไม่เชื่อมต่ออะไรล่ะ?  ในทาง electronics พูดง่ายๆ ว่า มันเชื่อมต่อ หรือไม่เชื่อมต่อ “สัญญาณทางไฟฟ้า” นั่นเอง แล้วเมื่อพูดถึงสัญญาณทางไฟฟ้า ก็มักจะหมายถึงการเปลี่ยนแปลงแรงดันไฟฟ้า หรือบางครั้งก็เรียกว่า ไฟ AC ซึ่งแตกต่างจากแรงดันไฟฟ้าที่ไม่เปลี่ยนแปลง หรือ DC ซึ่งมักจะเป็นไฟเลี้ยงวงจรไฟฟ้า

ดังนั้นเรามาสรุปย่อ ๆ ตรงนี้ก่อนว่า ในวงจร electronics นั้น มักจะมีทั้ง ไฟ DC ซึ่งเอาไว้เลี้ยงวงจรไฟฟ้า และ ไฟ AC ซึ่งมักจะเป็นสัญญาณไฟฟ้า และ coupling capacitor ก็ทำหน้าที่เชื่อมต่อสัญญาณไฟฟ้านั้น ส่วน decoupling capacitor ก็ทำหน้าที่ไม่เชื่อมต่อสัญญาณไฟฟ้านั้น

ทำไมต้องใช้ capacitor ในการ coupling หรือเชื่อมต่อสัญญาณด้วยล่ะ? ทำไมไม่ใช้ทองแดงต่อตรงไปเลย?

ในวงจร electronics นั้น (โดยเฉพาะที่เป็นในส่วนของวงจร analog นั้น) สัญญาณมักจะรวมอยู่กับ ไฟเลี้ยงซึ่งก็ไม่มีปัญหาอะไร แต่พอเราจะส่งสัญญาณจากจุดหนึ่งไปอีกจุดหนึ่งในวงจร หรือจากวงจรหนึ่งไปอีกวงจรหนึ่ง บางครั้งเราต้องการแค่เฉพาะตัวสัญญาณ ไม่ต้องการไฟเลี้ยง (อาจเป็นเพราะทั้งสองส่วนของวงจร หรือสองวงจรนั้น มีไฟเลี้ยงไม่เท่ากัน) เราจึงต้องอาศัยสมบัติของตัว capacitor ที่ยอมให้ไฟ AC ไหลผ่านมาช่วยเชื่อมต่อสัญญาณ และกันไม่ให้ DC ผ่านไปได้ เราจึงเรียก capacitor ที่ทำหน้าที่เชื่อมต่อสัญญาณนี้ว่า coupling capacitor นั่นเอง

ถ้าสัญญาณคือสิ่งที่เราต้องการ แล้วทำไมต้องมี decoupling capacitor ด้วยล่ะ?

ในวงจรหนึ่ง ๆ นอกจากไฟ AC ที่เป็นสัญญาณที่เราต้องการแล้ว ยังมักมีไฟ AC ที่เป็นสัญญาณที่เราไม่ต้องการด้วย เราเรียกสัญญาณ หรือไฟ AC ที่เราไม่ต้องการนี้ว่า noise (หรือ spike หรือ ripple หรืออื่น ๆ แล้วแต่รูปแบบการปรากฎตัวของมัน สรุปว่ามันคือสัญญาณที่เราไม่ต้องการ) โดยที่ noise นี้ มักจะเป็นสัญญาณที่มีความถี่สูงกว่าสัญญาณที่เราต้องการ แน่นอนว่าเราไม่อยากส่งต่อ noise ไปยังส่วนอื่นของวงจร หรือไม่อยากส่งต่อไปวงจรอื่น เราต้องเอา capacitor มาต่อระหว่างสายส่งสัญญาณกับ ground เพื่อให้ noise ลง ground ไป ไม่ให้เชื่อมต่อไปยังส่วนอื่น และ capacitor ที่ทำหน้าที่นี้ ก็เรียกว่า decoupling capacitor นั้นเอง หรือ capacitor ที่ทำหน้าที่ไม่เชื่อมต่อสัญญาณที่ไม่ต้องการ นั่นเอง

สรุปว่า ไม่ว่าจะเป็น coupling capacitor หรือ decoupling capacitor ก็คือ capacitor (ตัวเก็บประจุ) เหมือนกันนี่แหละ แต่ทำหน้าที่ต่างกัน โดยที่ coupling capacitor ทำหน้าที่เชื่อมต่อสัญญาณที่ต้องการ ส่วน decoupling capacitor ทำหน้าที่ไม่เชื่อมต่อสัญญาณที่ไม่ต้องการ บางครั้งเรียก decoupling capacitor นี้ว่า bypassing capacitor เพราะมัน bypass สัญญาณที่ไม่ต้องการไปทางอื่น เช่น ลง ground แต่สำหรับบางคน หรือบางบริบทก็อาจบอกว่ามันไม่เหมือนกันซะทีเดียวนะครับ

Posted on by — Leave a comment

วัดปริมาณ carbon dioxide ด้วย SCD-40 (Low power)

บทความนี้เป็นบทความต่อขยายจากบทความหลักในเรื่องของ “วัดปริมาณ carbon dioxide ด้วย SCD-40” โดยในบทความนี้จะกล่าวถึงการทำงานในโหมด Low power ซึ่งจะช่วยให้เราประหยัดพลังงานได้ โดยในบทความนี้สาธิตว่าทำอย่างไร และที่สำคัญ นอกจากช่วยลดการใช้พลังงงานแล้ว มีผลกระทบอื่น ๆ หรือไม่ แก้อย่างไร มาติดตามกันเลย

Low Power Periodic Measurement

ก่อนอื่นต้องทราบก่อนว่าส่วนที่ใช้พลังงานมากที่สุดของ SCD40 นี้คือการทำงานในส่วนของการวัดปริมาณ carbon dioxide ดังนั้นการลดความถึ่ในการวัดปริมาณ cabon dioxide จึงเป็นวิธีที่ตรงไปตรงมา และได้ผลมากโดยทางผู้ผลิตอ้างว่า สามารถลดพลังงานได้มากกว่า 80% เลยทีเดียว ซึ่งวิธีการก็ง่าย ๆ ไม่ยุ่งยากอะไร คือ ทางผู้ผลิตได้เตรียม function การใช้งานสำหรับเรื่องนี้มาโดยเฉพาะอยู่แล้ว นั่นคือ การใช้คำสั่ง startLowPowerPeriodicMeasurement แทนคำสั่ง startPeriodicMeasurement โดยคำสั่ง startLowPowerPeriodicMeasurement นี้เป็นการสั่งให้ SCD40 ทำการวัดค่า carbon dioxide ประมาณทุก ๆ 30 วินาที (จากเดิมทุก ๆ 5 วินาที) ซึ่งก็จะได้ code ดังนี้ (code ทั้งหมดจะให้ไว้ที่ด้านล่างของบทความนะครับ)

  scd40.begin(Wire);
  scd40.stopPeriodicMeasurement();
  // scd40.startPeriodicMeasurement();          // Performance mode (every 5s)
  scd40.startLowPowerPeriodicMeasurement();     // Low Power mode (every 30s)

แต่เรื่องมันไม่ได้จบแค่นี้ (ถ้าจบแค่นี้ก็ไม่สนุกใช่ไหมล่ะ)

Temperature Offset

เมื่อใช้ Low power mode นั้น ค่าของอุณหภูมิที่อ่านได้ จะคลาดเคลื่อนจากตอนที่อยู่ในโหมดปกตินิดหน่อย คาดว่าเกิดจากการใช้พลังงานลดลง ทำให้อุณหภูมิของตัวเอง (self-heating) ลดลง ทำให้ค่าอุณหภูมิที่วัดได้ต่างจากเดิมนิดหน่อย ดังนั้นเพื่อให้ sensor รายงานค่าอุณหภูมิ และความชื้นสัมพัทธ์ได้ถูกต้อง เราต้องปรับ offset ของการวัดอุณหภูมิของ sensor ด้วย ซึ่งตัว sensor เองก็มี function การทำงานในส่วนนี้รองรับไว้อยู่แล้ว (เจ๋ง ใช่ไหมล่ะ) นั่นคือใช้คำสั่ง setTemperatureOffset โดยที่ค่า offset ที่จะใส่เข้าไป สามารถหาได้ตามสูตร (จาก datasheet) ดังนี้

Toffset_actual = TSCD40 – TReference + Toffset_previous

Toffset_actual : ค่า offset ที่จะใส่เข้าไป

TSCD40 : ค่าอุณหภูมิที่ SCD40 อ่านได้

TReference : ค่าอุณหภูมิอ้างอิง (ที่เราคิดว่าถูกต้อง)

Toffset_previous : ค่า offset ปัจจุบัน (ก่อนที่จะใส่ offset ใหม่)

นอกจากปัจจัยในเรื่องของ self-heating ของตัว sensor เองแล้ว ยังมีปัจจัยจากสิ่งแวดล้อม เช่นความร้อนของอุปกรณ์ข้างเคียงอีก ดังนั้นเราควรหาค่า offset หลังจากที่ประกอบอุปกรณ์ในลักษณะพร้อมใช้ และติดตั้งในสถานที่จริงเรียบร้อยแล้ว ซึ่งจะเป็นลักษณะของใครของมัน ส่วนของผมนั้น ค่าอุณหภูมิที่อ่านได้ (TSCD40) จะน้อยกว่าค่าที่คิดว่าถูกต้อง (เมื่อเทียบกับ thermometer ที่เราเชื่อใจ ) อยู่ประมาณ 3.5 องศา (TSCD40 – TReference = -3.5) ส่วนค่า Toffset_previous คือค่า offset ปัจจุบัน เราสามารถหาได้จากคำสั่ง getTemperatureOffset

เมื่อได้ offset ที่ต้องการแล้ว เราก็ใส่ offset เข้าไปด้วยคำสั่ง setTemperatureOffset ซึ่งจะได้ code ดังนี้

  scd40.begin(Wire);
  scd40.stopPeriodicMeasurement();
  // scd40.startPeriodicMeasurement();          // Performance mode (every 5s)
  float tempOffsetPre = 0.0;
  scd40.getTemperatureOffset(tempOffsetPre);
  float tempOffset = -3.5 + tempOffsetPre;
  scd40.setTemperatureOffset(tempOffset);
  scd40.startLowPowerPeriodicMeasurement();     // Low Power mode (every 30s)

เมื่อเราปรับ code เป็นอย่างนี้แล้ว เราก็จะได้ค่าอุณหภูมิ และความชื้นสัมพัทธ์ถูกต้อง(มากขึ้น) ซึ่งการปรับค่าอุณหภูมินี้มีผลแค่การคำนวนค่าความชื้นสัมพัทธ์เท่านั้นนะครับ ไม่มีผลต่อการวัดค่า carbon dioxide ส่วนค่าที่จะมีผลต่อการวัดค่า carbon dioxide คือค่าความดันอากาศ ซึ่งยังไม่ได้กล่าวถึงในบทความนี้ แต่ใครสนใจสามารถศึกษาเพิ่มเติมได้จาก datasheet

Reload user setting from EEPROM

เอาหละ ถ้าดูผิวเผินก็เหมือนจะจบแค่นี้ แต่… ใช่แล้วครับ ความสนุกยังไม่จบแค่นี้ คนที่มีประสบการณ์ด้านการเขียนโปรแกรมมาเยอะ (ผิดพลาดมาเยอะ) ก็น่าจะรู้อยู่แล้วว่ามันยังไม่จบง่าย ๆ แบบนี้แน่ นั่นคือ ยังจำเหตุที่เราต้องใส่คำสั่ง stopPeriodicMeasurement ก่อนที่จะสั่ง startPeriodicMeasurement ได้ไหมครับ นั่นคือ เมื่อเรากด reset ที่ microcontroller ตัว SCD40 จะไม่ได้ reset ไปด้วย ดังนั้นถ้าเราปล่อยไว้อย่างนี้ จะทำให้ค่า offset จะถูกลดลงไป 3.5 องศาในทุก ๆ ครั้งที่เรากด reset ซึ่งไม่ดีแน่ แล้วเราจะแก้อย่างไรล่ะ

เราต้องเข้าใจการทำงานของ SCD40 เพิ่มอีกหน่อย นั่นคือ เมื่อเราจ่ายไฟให้กับ SCD40 นั้น ตัว sensor จะทำการ load ค่า setting ต่าง ๆ จาก EEPROM เข้าสู่ RAM เพื่อใช้ในการวัดค่าต่าง ๆ และคำสั่ง setTemperatureOffset ที่เราใช้เปลี่ยนค่า offset นี้ ก็ไปทำการเปลี่ยนค่า offset ที่ RAM เท่านั้น (ที่จริง เราสามารถบันทึกค่า offset ใหม่นี้ใส่ EEPROM ได้ แต่จะยังไม่พูดถึงในที่นี้) ดังนั้นเมื่อมีการกด reset ที่ microcontroller เราต้องการให้ SCD40 ทำการ reload ค่า setting ต่าง ๆ ขึ้นมาใหม่ด้วย ซึ่งแน่นอนว่าเค้าเตรียมให้เราอยู่แล้ว นั่นคือคำสั่ง reinit ซึ่งคำสั่งนี้ก็ต้องสั่งหลังจากคำสั่ง stopPeriodicMeasurement เช่นกัน ดังนั้นเราจะได้ code ออกมาอย่างนี้

  scd40.begin(Wire);
  scd40.stopPeriodicMeasurement();
  scd40.reinit();
  // scd40.startPeriodicMeasurement();          // Performance mode (every 5s)
  float tempOffsetPre = 0.0;
  scd40.getTemperatureOffset(tempOffsetPre);
  float tempOffset = -3.5 + tempOffsetPre;
  scd40.setTemperatureOffset(tempOffset);
  scd40.startLowPowerPeriodicMeasurement();     // Low Power mode (every 30s)

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

สลับโหมด

เอาหละ เหมือนจะจบแล้ว แต่ไหน ๆ เราก็เปลี่ยนโหมดได้ และมีโอกาสที่เราจะต้องการเปลี่ยนโหมดไปมาชั่วคราว เพื่อไม่ต้องเสียเวลามา upload program ใหม่ เราจะใช้สายไฟเพิ่มอีกสายหนึ่ง เพื่อให้เราสามารถกำหนดได้ว่า เราอยากใช้โหมดไหน โดยใช้ขาที่ยังว่าง ซึ่งก็มีอยู่มากมาย ในที่นี้จะใช้ขา D2 โดยถ้า D2 เป็น Low (ขา D2 ต่อลง GND)ให้ใช้ Low power mode ถ้าเป็น High (ขา D2 ต่อ 3.3 V) ให้ใช้ โหมดปกติ เราจะได้ code ดังนี้

  scd40.begin(Wire);
  scd40.stopPeriodicMeasurement();
  scd40.reinit();
  pinMode(2, INPUT);
  if (digitalRead(2)) {
    scd40.startPeriodicMeasurement();  // Performance mode (every 5s)
  } else {
    float tempOffsetPre = 0.0;
    scd40.getTemperatureOffset(tempOffsetPre);
    float tempOffset = -3.5 + tempOffsetPre;
    scd40.setTemperatureOffset(tempOffset);
    scd40.startLowPowerPeriodicMeasurement();  // Low Power mode (every 30s)
  }

เพียงเท่านี้ เราก็สามารถเลือกใช้ได้ทั้งสองโหมดเพียงแค่เปลี่ยนการเชื่อมต่อของขา D2 ด้วยสายไฟเพียงเส้นเดียว และอย่าลืมว่า เมื่อเปลี่ยนการเชื่อมต่อแล้วต้องกด reset ที่ microcontroller ด้วยนะครับ

Code ทั้งหมด

#include <SensirionI2CScd4x.h>
#include <U8g2lib.h>

#define BUZZER_PIN 7             // D7
#define CO2_THRESHOLD_BASE 1500  // ppm
#define ALARM_INTV 5000          // ms
#define ON 1
#define OFF 0

unsigned int alarmThreshold = CO2_THRESHOLD_BASE;
bool alarmStatus = OFF;
unsigned long alarmStart = 0;

SensirionI2CScd4x scd40;
uint16_t co2 = 0;
float temperature = 0.0;
float humidity = 0.0;

U8G2_SSD1306_128X64_NONAME_F_HW_I2C oled(U8G2_R0, /* reset=*/U8X8_PIN_NONE);

void setup() {

  Serial.begin(115200);
  // while (!Serial) {      // Waiting for connection wiht computer completed
  //     delay(100);
  // }

  oled.begin();
  oled.clearDisplay();
  oled.setContrast(1);

  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, OFF);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, OFF);

  scd40.begin(Wire);
  scd40.stopPeriodicMeasurement();
  scd40.reinit();
  pinMode(2, INPUT);
  if (digitalRead(2)) {
    scd40.startPeriodicMeasurement();  // Performance mode (every 5s)
  } else {
    float tempOffsetPre = 0.0;
    scd40.getTemperatureOffset(tempOffsetPre);
    float tempOffset = -3.5 + tempOffsetPre;
    scd40.setTemperatureOffset(tempOffset);
    scd40.startLowPowerPeriodicMeasurement();  // Low Power mode (every 30s)
  }
  
  Serial.println("Waiting for measurement...");

  oled.clearBuffer();
  oled.setFont(u8g2_font_siji_t_6x10);
  oled.drawStr(0, 30, "Waiting for");
  oled.drawStr(0, 40, "measurement....");
  oled.sendBuffer();
}

void loop() {

  bool dataReady = false;
  scd40.getDataReadyFlag(dataReady);
  if (dataReady) {

    scd40.readMeasurement(co2, temperature, humidity);

    Serial.print("CO2:");
    Serial.print(co2);
    Serial.print("  ");
    Serial.print("Temperature:");
    Serial.print(temperature);
    Serial.print("  ");
    Serial.print("Humidity:");
    Serial.println(humidity);

    oled.clearBuffer();

    oled.setFont(u8g2_font_8x13_tf);
    oled.drawStr(0, 10, "CO");
    oled.setFont(u8g2_font_siji_t_6x10);
    oled.drawStr(16, 14, "2");
    oled.setFont(u8g2_font_siji_t_6x10);
    oled.drawStr(0, 22, "(ppm)");

    String co2_string = String(co2);
    oled.setFont(u8g2_font_courB24_tf);
    int x_pos = (oled.getDisplayWidth() - oled.getStrWidth(co2_string.c_str()));
    oled.setCursor(x_pos, 22);
    oled.print(co2_string);

    oled.setFontMode(1);
    oled.setDrawColor(2);
    oled.drawBox(0, 31, 60, 11);
    oled.drawBox(70, 31, 60, 11);
    oled.setFont(u8g2_font_6x12_t_symbols);
    oled.drawGlyph(20, 41, 176);
    oled.drawGlyph(26, 40, 67);
    oled.drawStr(90, 40, "%");
    oled.drawStr(100, 40, "RH");

    oled.setFont(u8g2_font_courB18_tf);
    oled.setCursor(0, 62);
    oled.print(temperature, 1);
    oled.setCursor(70, 62);
    oled.print(humidity, 1);

    oled.sendBuffer();
  }  // if (dataReady)

  // Alarm Control
  alarmControl();

}  // Loop

void alarmControl(void) {
  if (co2 >= alarmThreshold) {
    if ((alarmStatus == OFF)) {
      setAlarm(ON);
      alarmStart = millis();

    } else if ((millis() - alarmStart) > ALARM_INTV) {
      setAlarm(OFF);
      alarmStart = 0;
      alarmThreshold = co2 + 500;
    }
  } else {
    setAlarm(OFF);
    alarmStart = 0;

    if (co2 < CO2_THRESHOLD_BASE) {
      alarmThreshold = CO2_THRESHOLD_BASE;
    }
  }
}

void setAlarm(bool state) {
  digitalWrite(BUZZER_PIN, state);
  digitalWrite(LED_BUILTIN, state);
  alarmStatus = state;
}

สรุป

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

ถาม: เราสามารถชดเชย (offset) ค่าอุณหภูมิเองใน code ได้หรือไม่ โดยไม่ต้องใช้ offset ใน sensor

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

ขอจบความสนุกของบทความนี้ไว้เพียงเท่านี้ ส่วนใครที่ยังไม่อยากหยุดสนุก ผมก็ขอฝากโจทย์ว่า จาก code ที่ให้ไปเป็นการใส่ offset ในส่วนของโหมด low power เท่านั้น ถ้าต้องการใส่ offset ที่โหมดปกติด้วย จะต้องปรับ code อย่างไร

ที่มา

  1. SCD4X datasheet
  2. SCD4X Low power operation
Posted on by — Leave a comment

วัดปริมาณ carbon dioxide ด้วย SCD-40

ในบทความนี้เป็นการสาธิตการใช้ SCD-40 ในการวัดปริมาณ Carbon dioxide (CO2) ซึ่ง SCD-40 มีความยืดหยุ่นน่าใช้มาก ๆ เช่น มีทั้งโหมดปกติ และ โหมดประหยัดพลังงานให้เลือกใช้ให้เหมาะสมกับความต้องการ สามารถ calibrate ได้ทั้งแบบ auto และ manual และยังสามารถปรับ offset ให้กับค่าอุณหภูมิที่วัดได้เพื่อให้ SCD-40 คำนวนค่าความชื้นได้ถูกต้องมากยิ่งขึ้น โดยในครั้งนี้เราจะทำแบบง่าย ๆ ก่อน โดยให้วัดค่า carbon dioxide ในโหมดปกติ แล้วแสดงผลที่ computer ผ่าน USB พร้อมทั้งแสดงผลที่หน้าจอ OLED และสามารถร้องเตือน (Alarm) เมื่อค่า carbon dioxide ที่อ่านได้เกินค่าที่กำหนด ในที่นี้จะกำหนดค่าเริ่มต้นที่ 1500 ppm

สิ่งที่ต้องเตรียมมีดังนี้

อุปกรณ์

  1. Arduino Nano RP2040 Connect
  2. Carbon dioxide Sensor (SCD-40)
  3. 128×64 SSD1036 OLED 
  4. Buzzer
  5. Breadboard and Jumping Wire

Library

  1. SCD-40 library (Sensirion)
  2. SSD1036 OLED library (U8g2)

ติดตั้ง Hardware

เนื่องจากเราจะสื่อสารระหว่าง Arduino Nano RP2040 Connect กับ SCD-40 และ OLED ผ่าน I2C และ ควบคุม Buzzer ผ่าน Digital I/O โดยเลือกขาที่สะดวก ในที่นี้คือ ขา D7 ดังนั้นเราจะต่อ hardware ดังนี้

Arduino Nano ConnectSCD-40OLEDBuzzer
VINVCCVCC 
GNDGNDGND 
A5 (SLK)SLKSLK 
A4 (SDA)SDASDA 
D7  ขาบวก (ขาที่ยาวกว่า)
Hardware connecting table

ติดตั้ง Library

            ในที่นี้เราจะใช้ library ของ Sensirion สำหรับ SCD-40 และ U8g2 สำหรับ OLED โดยวิธีการติดตั้งสามารถดูได้จากบทความเรื่อง “การติดตั้ง library”

Code

#include

โดยเริ่มต้นเราต้อง include สิ่งที่เราต้องใช้ในที่นี้คือ library ต่าง ๆ เช่น SCD-40 และ OLED

#include <SensirionI2CScd4x.h>
#include <U8g2lib.h>

กำหนดชื่อให้กับ ขาที่ต่อกับ Buzzer และเงื่อนไขในการร้องเตือน (Alarm) ของ Buzzer โดยต้องการให้ Buzzer ร้องเตือนเมื่อค่า carbon dioxide ที่อ่านได้มีค่าตั้งแต่ 1500 ppm ขึ้นไป (CO2_THRESHOLD_BASE) และให้ร้องเตือนเป็นเวลา 5 วินาที (ALARM_INTV) 

#define BUZZER_PIN 7              // D7
#define CO2_THRESHOLD_BASE 1500   // ppm
#define ALARM_INTV 5000           // ms
#define ON 1
#define OFF 0

สร้างตัวแปรที่จำเป็นสำหรับการควบคุมการร้องเตือน โดยมีตัวแปรสำหรับเก็บค่า threshold ที่จะร้องเตือน (alarmThreshold)  ตัวแปรใช้เก็บเวลาที่เริ่มร้องเตือน (alarmStart) และ ตัวแปรสำหรับเก็บสถานะการร้องเตือน (alarmStatus)

unsigned int alarmThreshold = CO2_THRESHOLD_BASE;
bool alarmStatus = OFF;
unsigned long alarmStart = 0;

สร้าง object ที่เป็น sensor และกำหนดตัวแปรสำหรับรับค่าที่อ่านได้จาก SCD40

SensirionI2CScd4x scd40;
uint16_t co2 = 0;
float temperature = 0.0;
float humidity = 0.0;

สร้าง object ที่เป็นหน้าจอ OLED

U8G2_SSD1306_128X64_NONAME_F_HW_I2C oled(U8G2_R0, /* reset=*/U8X8_PIN_NONE);

Setup()

เตรียมความพร้อม(initial)ให้กับ hardware ต่าง ๆ ของเรา

เริ่มจากเชื่อมต่อกับ computer ผ่าน Serial (USB) ด้วยคำสั่ง begin และรอให้การเชื่อมต่อเสร็จเรียบร้อย (ด้วย while loop) ก่อนที่จะทำงานอื่น ๆ ต่อไป เพื่อที่ว่า ถ้าเราจะรีบส่งข้อความอะไรไปยัง computer ข้อความเหล่านั้นจะได้ไม่ตกหล่น ถ้าการเชื่อมต่อยังไม่เสร็จเรียบร้อย ข้อความที่เราส่งก็จะตกหล่นหายไป

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

  Serial.begin(115200);
  // while (!Serial) {      // Waiting for connection wiht computer completed
  //     delay(100);
  // }

เริ่มต้นการทำงานของ OLED ด้วยคำสั่ง begin แล้วสั่งให้ clear หน้าจอ และปรับความสว่างที่ต้องการ (โดยใช้คำสั่ง setContrast())

  oled.begin();
  oled.clearDisplay();
  oled.setContrast(1);

กำหนดโหมดและค่าเริ่มต้นให้กับ I/O ซึ่งก็คือขาควบคุม Buzzer และ LED_BUILTIN

  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, OFF);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, OFF);

เริ่มต้นการทำงานของ carbon dioxide sensor (SCD-40) โดยส่งคำสั่ง begin แล้วตามด้วยคำสั่ง stopPeriodicMeasurement (stop) ก่อนที่จะสั่ง startPeriodicMeasurement (start) เพื่อเริ่มการวัดค่า carbon dioxide 

สังเกตว่า เราต้องสั่ง stop ก่อนสั่ง start นั่นเพราะว่า เมื่อเราสั่ง start แล้ว sensor จะไม่รับหลาย ๆ คำสั่ง รวมทั้ง start ซ้ำด้วย ดังนั้น ถ้าเราไม่สั่ง stop ก่อนที่จะสั่ง start นั้นจะทำให้เกิดปัญหาเวลาที่เรา upload โปรแกรมเข้าไปใหม่ ในระหว่างการพัฒนา หรือ ตอนที่เรากด “reset” ที่ตัว Arduino เพราะ SCD40 จะมองว่าเป็นการสั่ง start ซ้ำ เนื่องจากเวลาที่เรา upload โปรแกรมใหม่ หรือ การกดปุ่ม reset ที่ตัว Arduino นั้น ตัว sensor ไม่ได้ reset ไปพร้อมกับ Arduino ด้วยนั่นเอง

  scd40.begin(Wire);
  scd40.stopPeriodicMeasurement();
  scd40.startPeriodicMeasurement();

จากคู่มือของ SCD40 เมื่อสั่ง startPeriodicMeasurement แล้ว sensor จะทำการอ่านค่า carbon dioxide ทุก ๆ 5 วินาที ดังนั้น เมื่อสั่ง start แล้วเราก็ต้องรออย่างน้อย 5 วินาที ถึงจะอ่านค่าได้ ดังนั้นแทนที่จะรออยู่เงียบ ๆ เราก็แจ้งให้ผู้ใช้ทราบเสียหน่อยว่า เรากำลังรอการวัดค่าอยู่นะ เพื่อป้องกันการตกใจว่า เอ๊ะ! ทำไมไม่ทำงาน โดยการ ส่งข้อความไปแสดงที่ computer และแสดงข้อความที่หน้าจอ OLED ด้วย

  Serial.println("Waiting for measurement...");

ส่วนการแสดงข้อความที่หน้าจอ OLED จะยุ่งยากกว่านิดหน่อย และการที่เราจะสั่งว่าให้แสดงอะไรออกที่หน้าจอนั้น มันจะไม่ได้ออกไปที่หน้าจอทันที มันจะเป็นการเก็บข้อมูลที่เราจะให้แสดงออกหน้าจอนั้นไว้ที่ memory ที่เรียกว่า buffer ก่อน แล้วค่อยส่งข้อมูลจาก buffer ออกหน้าจอทีเดียว ดังนั้น ขั้นตอนในการแสดงข้อมูลที่หน้าจอก็จะเริ่มด้วย การ clear buffer (clearBuffer) แล้วก็ส่งข้อมูลที่จะแสดงที่หน้าจอไปเก็บยัง buffer โดยที่เราต้องกำหนด Font เอง ซึ่งเราต้องเลือกทั้งลักษณะ และขนาด (เลือกได้จาก https://github.com/olikraus/u8g2/wiki/fntlistall) และ กำหนดตำแหน่งที่จะแสดงตัวหนังสือบนหน้าจอเองด้วย รวมทั้ง ถ้าข้อความยาวเกินกว่าหน้าจอ เราก็ต้องแบ่งบรรทัดเองอีกด้วย (แต่ถึงแม้ว่าจะรู้สึกว่ามันยุ่งยากจัง แต่พอเริ่มชินแล้วเราจะชอบ เพราะมันให้อิสระเราในการทำอะไรกับหน้าจอก็ได้เลย) หลังจากสั่งว่าจะให้แสดงอะไรออกที่หน้าจอแล้ว เราก็ทำการส่งข้อความทั้งหมดที่อยู่ใน buffer (sendBuffer) ออกไปที่หน้าจอพร้อมกันก็จะได้โค้ดดังนี้

  oled.clearBuffer();
  oled.setFont(u8g2_font_siji_t_6x10);
  oled.drawStr(0, 30, "Waiting for");
  oled.drawStr(0, 40, "measurement....");
  oled.sendBuffer();

Loop()

ในส่วนของ loop เราจะให้มีการทำงานดังนี้

Data Ready?

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

  bool dataReady = false;
  scd40.getDataReadyFlag(dataReady);
  if (dataReady) {

อ่านค่า CO2, Temperature, Humidity

ถ้ามีข้อมูลแล้ว ค่อยเรียกใช้คำสั่ง readMeasurement เพื่ออ่านข้อมูลจาก SCD40 ง่าย ๆ ทีเดียวได้ทั้งสามค่าเลย  ดังนี้

    scd40.readMeasurement(co2, temperature, humidity);

แสดงค่าที่ computer

จากนั้นก็นำค่าที่ได้เหล่านี้ส่งไปที่ computer ผ่านสาย USB ด้วยคำสั่ง Serial.print() ดังนี้

    Serial.print("CO2:");
    Serial.print(co2);
    Serial.print("  ");
    Serial.print("Temperature:");
    Serial.print(temperature);
    Serial.print("  ");
    Serial.print("Humidity:");
    Serial.println(humidity);

คำสั่ง print() ทั้งหมดนี้จะแสดงค่าต่าง ๆ ออกมาอยู่บรรทัดเดียวกัน และมีคำสั่ง println() ในบรรทัดสุดท้าย เพื่อบอกว่า เมื่อแสดงค่าแล้วให้ขึ้นบรรทัดใหม่ เพื่อเตรียมแสดงข้อมูลชุดต่อไป ซึ่งถ้าเราใช้ Tools -> Serial Monitor ก็จะเห็นข้อมูลส่งมาดังนี้

และเมื่อเราใช้ Tools -> Serial Plotter ก็จะได้กราฟแสดงข้อมูลทั้งสามออกมาสวย ๆ ดังนี้

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

แสดงค่าที่ OLED

ต่อมาเราก็แสดงค่าที่อ่านได้บนหน้าจด OLED ด้วย โดยเราเริ่มจาก clearBuffer เพื่อที่จะล้าง memory ที่เก็บข้อมูลสำหรับแสดงที่หน้าจอ OLED แล้วเราก็ใส่คำสั่งต่าง ๆ เพื่อที่จะส่งค่าที่จะแสดงที่หน้าจอลง buffer แล้วปิดท้ายด้วยคำสั่ง sendBuffer() เพื่อส่งข้อมูลใน buffer ทั้งหมดไปแสดงที่หน้าจอ OLED ดังนี้

    oled.clearBuffer();

    oled.setFont(u8g2_font_8x13_tf);
    oled.drawStr(0, 10, "CO");
    oled.setFont(u8g2_font_siji_t_6x10);
    oled.drawStr(16, 14, "2");
    oled.setFont(u8g2_font_siji_t_6x10);
    oled.drawStr(0, 22, "(ppm)");

    String co2_string = String(co2);
    oled.setFont(u8g2_font_courB24_tf);
    int x_pos = (oled.getDisplayWidth() - oled.getStrWidth(co2_string.c_str()));
    oled.setCursor(x_pos, 22);
    oled.print(co2_string);

    oled.setFontMode(1);
    oled.setDrawColor(2);
    oled.drawBox(0, 31, 60, 11);
    oled.drawBox(70, 31, 60, 11);
    oled.setFont(u8g2_font_6x12_t_symbols);
    oled.drawGlyph(20, 41, 176);
    oled.drawGlyph(26, 40, 67);
    oled.drawStr(90, 40, "%");
    oled.drawStr(100, 40, "RH");

    oled.setFont(u8g2_font_courB18_tf);
    oled.setCursor(0, 62);
    oled.print(temperature, 1);
    oled.setCursor(70, 62);
    oled.print(humidity, 1);

    oled.sendBuffer();

ซึ่งจากโค้ดด้านบน ก็จะได้หน้าจอออกมาแบบนี้ ส่วนใครชอบแบบไหนก็ลองปรับแต่งกันดู

ควบคุม Alarm (alarmControl)

ในส่วนของ การควบคุม Alarm (buzzer ส่งเสียง และ LED สว่าง) จะแยกเป็นอีก function เพื่อไม่ให้ดูยุ่งเกินไป ในส่วนของ Alarm นี้อาจทำง่าย ๆ แค่ ถ้าค่า CO2 ที่อ่านได้เกินค่าที่กำหนด ก็ให้ Alarm ถ้าเมื่อใดค่าที่อ่านได้ต่ำกว่าค่าที่กำหนดก็หยุด Alarm 

แต่จากประสบการณ์ มันจะค่อนข้างน่ารำคาญถ้าจะให้ Alarm โดยให้ buzzer ดังตลอดจนกว่าค่า CO2 จะต่ำกว่าที่กำหนด ดังนั้นจึงให้ Alarm แค่เวลาที่กำหนด (ในที่นี้คือ 5 วินาที ซึ่งสามารถเปลี่ยนแปลงได้โดยเปลี่ยนค่า ALARM_INTV) แล้วให้ดังอีกครั้งเมื่อค่า CO2 ที่วัดได้เกินค่าปัจจุบันไปอีก 500 ppm ซึ่งก็จะ Alarm อย่างนี้ไปเรื่อย ๆ จนกว่าค่า CO2 จะต่ำกว่าค่าเริ่มต้น (CO2_TRESHOLD_BASE) จึงปรับค่า threshold กลับมาเป็น ค่าเริ่มต้นอีกครั้ง โดยมี logic การทำงานดังนี้

ก็จะได้ code ออกมาดังนี้

void alarmControl() {
  if (co2 >= alarmThreshold) {
    if ((alarmStatus == OFF)) {
      digitalWrite(BUZZER_PIN, HIGH);   // Alarm
      digitalWrite(LED_BUILTIN, HIGH);  // Alarm
      alarmStatus = ON;                 // Alarm
      alarmStart = millis();

    } else if ((millis() - alarmStart) > ALARM_INTV) {
      digitalWrite(BUZZER_PIN, LOW);    // Alarm
      digitalWrite(LED_BUILTIN, LOW);   // Alarm
      alarmStatus = OFF;                // Alarm
      alarmStart = 0;
      alarmThreshold = co2 + 500;
    }
  } else {
    digitalWrite(BUZZER_PIN, LOW);      // Alarm
    digitalWrite(LED_BUILTIN, LOW);     // Alarm
    alarmStatus = OFF;                  // Alarm
    alarmStart = 0;

    if (co2 < CO2_THRESHOLD_BASE) {
      alarmThreshold = CO2_THRESHOLD_BASE;
    }
  }
}

ข้อสังเกต

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

void setAlarm(bool state) {
  digitalWrite(BUZZER_PIN, state);
  digitalWrite(LED_BUILTIN, state);
  alarmStatus = state;
}

และ code ในส่วน alarmControl() ก็จะเป็นอย่างนี้

void alarmControl(void) {
  if (co2 >= alarmThreshold) {
    if ((alarmStatus == OFF)) {
      setAlarm(ON);
      alarmStart = millis();

    } else if ((millis() - alarmStart) > ALARM_INTV) {
      setAlarm(OFF);
      alarmStart = 0;
      alarmThreshold = co2 + 500;
    }
  } else {
    setAlarm(OFF);
    alarmStart = 0;

    if (co2 < CO2_THRESHOLD_BASE) {
      alarmThreshold = CO2_THRESHOLD_BASE;
    }
  }
}

เพียงเท่านี้ เราก็จะได้เครื่องวัด carbon dioxide ไว้เล่นสนุกแล้ว

เพื่อความสะดวกในการใช้งาน และความสวยงาม ก็สามารถนำไปใส่กล่อง หรือขวดให้เหมาะสมได้

เพื่อความสะดวก ด้านล่างนี้คือ code ทั้งหมดครับ

#include <SensirionI2CScd4x.h>
#include <U8g2lib.h>

#define BUZZER_PIN 7              // D7
#define CO2_THRESHOLD_BASE 1500   // ppm
#define ALARM_INTV 5000           // ms
#define ON 1
#define OFF 0

unsigned int alarmThreshold = CO2_THRESHOLD_BASE;
bool alarmStatus = OFF;
unsigned long alarmStart = 0;

SensirionI2CScd4x scd40;
uint16_t co2 = 0;
float temperature = 0.0;
float humidity = 0.0;

U8G2_SSD1306_128X64_NONAME_F_HW_I2C oled(U8G2_R0, /* reset=*/U8X8_PIN_NONE);

void setup() {
  
  Serial.begin(115200);
  while (!Serial) {      // Waiting for connection wiht computer completed
      delay(100);
  }

  oled.begin();
  oled.clearDisplay();
  oled.setContrast(1);

  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, OFF);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, OFF);

  scd40.begin(Wire);
  scd40.stopPeriodicMeasurement();
  scd40.startPeriodicMeasurement();

  Serial.println("Waiting for measurement...");

  // oled.clearBuffer();
  oled.setFont(u8g2_font_siji_t_6x10);
  oled.drawStr(0, 30, "Waiting for");
  oled.drawStr(0, 40, "measurement....");
  oled.sendBuffer();
}

void loop() {

  bool dataReady = false;
  scd40.getDataReadyFlag(dataReady);
  if (dataReady) {

    scd40.readMeasurement(co2, temperature, humidity);

    Serial.print("CO2:");
    Serial.print(co2);
    Serial.print("  ");
    Serial.print("Temperature:");
    Serial.print(temperature);
    Serial.print("  ");
    Serial.print("Humidity:");
    Serial.println(humidity);

    oled.clearBuffer();

    oled.setFont(u8g2_font_8x13_tf);
    oled.drawStr(0, 10, "CO");
    oled.setFont(u8g2_font_siji_t_6x10);
    oled.drawStr(16, 14, "2");
    oled.setFont(u8g2_font_siji_t_6x10);
    oled.drawStr(0, 22, "(ppm)");

    String co2_string = String(co2);
    oled.setFont(u8g2_font_courB24_tf);
    int x_pos = (oled.getDisplayWidth() - oled.getStrWidth(co2_string.c_str()));
    oled.setCursor(x_pos, 22);
    oled.print(co2_string);

    oled.setFontMode(1);
    oled.setDrawColor(2);
    oled.drawBox(0, 31, 60, 11);
    oled.drawBox(70, 31, 60, 11);
    oled.setFont(u8g2_font_6x12_t_symbols);
    oled.drawGlyph(20, 41, 176);
    oled.drawGlyph(26, 40, 67);
    oled.drawStr(90, 40, "%");
    oled.drawStr(100, 40, "RH");

    oled.setFont(u8g2_font_courB18_tf);
    oled.setCursor(0, 62);
    oled.print(temperature, 1);
    oled.setCursor(70, 62);
    oled.print(humidity, 1);

    oled.sendBuffer();
  }  // if (dataReady)

  // Alarm Control
  alarmControl();

}  // Loop

void alarmControl(void) {
  if (co2 >= alarmThreshold) {
    if ((alarmStatus == OFF)) {
      setAlarm(ON);
      alarmStart = millis();

    } else if ((millis() - alarmStart) > ALARM_INTV) {
      setAlarm(OFF);
      alarmStart = 0;
      alarmThreshold = co2 + 500;
    }
  } else {
    setAlarm(OFF);
    alarmStart = 0;

    if (co2 < CO2_THRESHOLD_BASE) {
      alarmThreshold = CO2_THRESHOLD_BASE;
    }
  }
}

void setAlarm(bool state) {
  digitalWrite(BUZZER_PIN, state);
  digitalWrite(LED_BUILTIN, state);
  alarmStatus = state;
}

คำเตือน

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

ในตอนต่อ ๆ ไป เราจะมาปรับปรุงระบบนี้ให้น่าสนใจมากยิ่งขึ้นไปอีก เพราะยังมีอะไรให้ทำกับระบบนี้อีกมาก เช่น สามารถ calibrate ค่า CO2 ได้ สามารถกำหนด offset ให้กับค่าอุณหภูมิที่อ่านได้ ทำให้ได้ค่าอุณหภูมิ และความชื้นที่ถูกต้องมากยิ่งขึ้น รวมทั้ง เราจะใช้ความสามารถความเป็น dual core ของ RP2040 มาใช้ประโยชน์ และการอ่านค่าจากระยะไกล โดยใช้ Bluetooth หรือแม้แต่ส่งขึ้น cloud เพื่อ monitor ได้จากมืออีกด้วย น่าสนใจมาก ๆ ใช่ไหมล่ะครับ คอยติดตามกันนะครับ

เอกสารอ้างอิง

  1. SCD-40 data sheet (https://sensirion.com/media/documents/E0F04247/631EF271/CD_DS_SCD40_SCD41_Datasheet_D1.pdf)
Posted on by — Leave a comment

TinyML คืออะไร

จากชื่อก็พอจะเดาได้ว่า Tiny คือ เล็กๆ และ ML ก็มาจาก Machine Learning รวมกันก็คือ machine learning ขนาดเล็ก แล้วเล็กแค่ไหนถึงเรียกว่า TinyML ล่ะ ก็เล็กขนาดที่ทำงานอยู่บน microcontroller ได้นั่นแหละ ถึงแม้ว่าจะเรียก machine learning แต่ก็มักจะไม่มีการเรียนรู้บน microcontroller (แม้ว่าจะทำได้ก็ตาม) มักมีเพียงการตัดสินใจ (inference) เท่านั้น การเรียนรู้ (trainging) จะเกิดบน desktop หรือ server แล้วนำสิ่งที่เรียนรู้ได้นั้น มาใช้บน microcontroller นั่นเป็นเพราะว่าขั้นตอนการเรียนรู้นั้นต้องการการคำนวนที่มาก และต้องใช้เวลานาน ทำให้ไม่สะดวกที่จะเรียนรู้บน microcontroller อีกเหตุผลหนึ่งก็คือ ในหลายกรณีไม่มีความจำเป็น หรือไม่ควรเรียนรู้บน microcontroller เนื่องจาก การเรียนรู้ (training) มักต้องการนักวิทยาศาสตร์ หรือผู้เชี่ยวชาญคอยดูแลขั้นตอนการเรียนรู้ เพื่อให้การเรียนรู้เป็นไปอย่างเหมาะสม ดังนั้นบน microcontroller จึงมักมีเพียงแค่ส่วนของการทำงานที่เป็นการตัดสินใจ (inference) เท่านั้น

ทำไมต้อง TinyML

จากข้อจำกัดเรื่องการเรียนรู้ (training) แล้วทำไมต้องใช้ TinyML ด้วยล่ะ ทำไมไม่เอา ML ที่ทำงานบน server หรือ desktop ไปใช้หน้างานเลยล่ะ หรือทำไมไม่ใช้ microcontroller เป็นตัวเก็บข้อมูลหน้างาน แล้วส่งให้ ML บน server หรือ desktop ตัดสินใจ แล้วค่อยส่งผลการตัดสินใจกลับมาให้ microcontroller ที่หน้างานล่ะ นั่นเป็นเพราะ ถึงแม้ว่า TinyML จะทำได้แค่ตัดสินใจ แต่ก็มีข้อได้เปรียบเหนือ ML ที่ทำงานอยู่บน server หรือ desktop หลายอย่าง เช่น

  1. ความปลอดภัยของข้อมูล เนื่องจาก microcontroller สามารถตัดสินใจได้โดยไม่มีการส่งข้อมูลไปให้ server ทำให้มีความปลอดภัยของข้อมูลมากขึ้น โดยเฉพาะเรื่องความเป็นส่วนตัวของข้อมูล (data privacy)
  2. ต้องการ Bandwidth ต่ำ เนื่องจากการตัดสินใจ สามารถทำได้บน microcontroller จึงไม่จำเป็นต้องสื่อสารกับ server ด้วยข้อมูลปริมาณมาก ทำให้ไม่จำเป็นที่ต้องใช้การสื่อสารที่มี bandwidth สูง ซึ่งช่วยประหยัดต้นทุนได้
  3. ประหยัดพลังงาน เนื่องจาก microcontroller ใช้พลังงานน้อยกว่า desktop หรือ server หรือแม้แต่ single board computer อย่าง Raspberry Pi มาก ทำให้สามารถใช้กับ battery ก้อนเล็ก ๆ ได้
  4. ขนาดเล็ก เนื่องจาก microcontroller มีขนาดเล็กทำให้สะดวกที่จะติดตั้งลงบนอุปกรณ์ที่ขนาดไม่ใหญ่มาก เช่น drone หรืออุปกรณ์พกพาอื่น ๆ ได้ง่าย
Posted on by — Leave a comment

Bluetooth BR/EDR และ Bluetooth Low Energy (LE) คืออะไร

Bluetooth BR/EDR

Bluetooth BR/EDR หรือเรียกว่า Bluetooth Classic เป็นจุดเริ่มต้นของ Bluetooth technology โดยเริ่มต้นจากการเป็น technology ติดต่อสื่อสารระหว่าง 2 อุปกรณ์แบบ 1 ต่อ 1 (point to point) โดยไม่ต้องมีอุปกรณ์ช่วยสื่อสารอื่น ๆ เข้ามาเกี่ยวข้อง โดยเริ่มต้นนั้นเป็น Bluetooth BR (Basic rate) ที่มีความเร็วในการส่งข้อมูลที่ 1 Mb/s และต่อมาได้พัฒนาให้มีความสามารถส่งข้อมูลได้เร็วขึ้นเป็น 2 Mb/s เรียกว่า Bluetooth EDR (Enhance Data rate) ซึ่ง Bluetooth Classic ได้รับความนิยมอย่างมากสำหรับอุปกรณ์ไร้สายต่าง ๆ เช่น mouse หรือ keyboard โดยเฉพาะอย่างยิ่ง  audio streaming เช่น ลำโพงไร้สายต่าง ๆ

Bluetooth Low Energy (LE)

ตั้งแต่ Bluetooth v4.0 เป็นต้นมา Bluetooth ได้ถูกพัฒนาให้ใช้พลังงานอย่างมีประสิทธิภาพมากขึ้น เรียกว่า Bluetooth Low Energy (LE) นอกจากนี้ยังถูกพัฒนาให้รองรับการเชื่อมต่อหลายรูปแบบ ทั้ง 1 – 1, Broadcast, Mesh ทำให้สามารถสร้างกลุ่มของการสื่อสารของอุปกรณ์หลาย ๆ ตัวได้ และสื่อสารได้ไกลขึ้น โดยการถ่ายทอดข้อมูลผ่านอุปกรณ์ตัวที่อยู่ใกล้เคียงออกไปยังอุปกรณ์ที่ต้องการ ในปัจจุบันยังรองรับการทำ device positioning คือการบอกตำแหน่ง และทิศทางของตัวอุปกรณ์ได้อีกด้วย เหมาะสำหรับการบอกตำแหน่งของอุปกรณ์ในพื้นที่ไม่กว้างมากนัก เช่น ในอาคาร หรือลานจอดรถได้เป็นอย่างดี

อ้างอิงจาก:

https://www.bluetooth.com/learn-about-bluetooth/tech-overview/

Posted on by — Leave a comment

Transmissive & Photoacoustic NDIR sensing technology คืออะไร

เป็น technology ในการวัดปริมาณก๊าซ โดยใช้สมบัติการดูดกลืนคลื่นแม่เหล็กไฟฟ้าของโมเลกุลของก๊าซช่วง infra-red (IR)

หลักการทำงาน

ก่อนจะอธิบายการทำงานของ sensor ต้องขออธิบายธรรมชาติของก๊าซที่สำคัญอย่างหนึ่งก่อน นั่นคือ โมเลกุลของก๊าซ สามารถดูดกลืนคลื่นแม่เหล็กไฟฟ้าในบางความยาวคลื่นได้ โดยที่โมเลกุลของก๊าซแต่ละชนิดสามารถดูดกลืนคลื่นแม่เหล็กไฟฟ้าได้ดีที่ความยาวคลื่นต่างกัน เช่น carbon dioxide นั้น สามารถดูดกลืนแม่เหล็กไฟฟ้าที่ความยาวคลื่นประมาณ 4.2 ไมโครเมตร ได้ดี

ที่มา เอกสารของ Sensirion

ซึ่งคลื่นแม่เหล็กไฟฟ้าที่ความยาว 4.2 ไมโครเมตรนี้อยู่ในช่วงที่เรียกว่า Infra-red (IR) จากสมบัติที่สำคัญนี้ทำให้เราสามารถตรวจวัดปริมาณของก๊าซ carbon dioxide ได้ โดยดูจากประมาณการดูดกลืนคลื่นแม่เหล็กไฟฟ้าที่ความยาวคลื่น 4.2 ไมโครเมตรนี้ 

Non Dispersive Infra-red (NDIR)

โดยปกติ ถ้าเราต้องการคลื่นแม่เหล็กไฟฟ้าความยาวคลื่นเดียว หรืออยู่ในช่วงแคบ ๆ เราอาจต้องใช้อุปกรณ์ช่วยในการแยกคลื่นแม่เหล็กไฟฟ้าที่เราต้องการออกจากคลื่นแม่เหล็กไฟฟ้าความยาวคลื่นอื่น ๆ เนื่องจากแหล่งกำเนิดมักมีคลื่นแม่เหล็กไฟฟ้าหลายความยาวคลื่นปนกันมา ยกตัวอย่างคลื่นแม่เหล็กไฟฟ้าที่รู้จักกันดีคือ คลื่นแสง ซึ่งประกอบด้วยคลื่นแม่เหล็กไฟฟ้าความยาวคลื่นตั้งแต่ 400 นาโนเมตร ไปจนถึง 750 นาโนเมตร ดังนั้น  การจะได้ความยาวคลื่นเดียว ก็ต้องใช้ อุปกรณ์ที่เป็นตัวกระจาย (dispersive element) คลื่นแสง เช่น ปริซึม (prism) หรือ เกรตติ้ง(diffraction grating) หรืออีกวิธีหนึ่งคือการใช้ filter คืออุปกรณ์ที่ยอมให้คลื่นแสงที่เราต้องการผ่านไปได้เท่านั้น วิธีนี้ไม่ใช้ dispersive element จึงเรียกว่า Non Dispersive ในทำนองเดียวกัน ถ้าเราใช้ filter เพื่อให้ได้คลื่นแม่เหล็กไฟฟ้าที่ความยาวช่วง IR เราก็จะเรียกว่า Non Dispersive Infra-red (NDIR)

Transmissive NDIR

จากการที่โมเลกุลของก๊าซสามารถดูดกลืนคลื่นแม่เหล็กไฟฟ้าที่ความยาวคลื่น 4.2 ไมโครเมตร ได้นี้ เราก็สามารถวัดปริมาณ carbon dioxide ได้ โดยตรวจวัดปริมาณคลื่นแม่เหล็กไฟฟ้าที่ไม่ถูกดูดกลืน วิธีที่เรียกว่า Transmissive NDIR โดยมีแหล่งกำเนิดของคลื่นแม่เหล็กไฟฟ้าในช่วง IR แล้วผ่าน filter เพื่อให้ได้คลื่น 4.2 ไมโครเมตร แล้วผ่าน ห้องวัด(measurement chamber) ที่มีก๊าซ carbon dioxide แล้วให้คลื่น IR ที่เหลือจากการดูดกลืนตกกระทบบน sensor สำหรับตรวจ IR เพื่อวัดปริมาณ IR ที่เหลือจากการดูดกลืนของโมเลกุลของ carbon dioxide

ที่มา เอกสารของ Sensirion

ถ้าปริมาณคลื่น IR ผ่านกระทบกับ IR sensor ได้มาก แสดงว่ามี carbon dioxide อยู่น้อย ถ้ามีปริมาณ IR ผ่านมาได้น้อย แสดงว่ามีปริมาณ carbon dioxide อยู่มากนั่นเอง วิธีนี้ตัว IR sensor นั้นต้องอยู่ตรงข้ามกับแหล่งกำเนิด IR และมี carbon dioxide อยู่ระหว่างนั้น ทำให้ตัวเครื่องมือวัดต้องมีความยาวพอสมควร

Photoacoustic NDIR

อีกวิธีหนึ่งที่ใช้วัดปริมาณก๊าซได้ โดยทำงานด้วยหลักการที่ว่า เมื่อโมเลกุลของก๊าซ carbon dioxide ดูดกลืนคลื่นแม่เหล็กไฟฟ้าเข้าไปแล้ว จะเกิดการสั่นของโมเลกุล เมื่อมีการสั่นก็จะทำให้เกิดเสียง ดังนั้นจึงใช้ไมโครโฟน(ขนาดเล็กมาก) ตรวจจับปริมาณเสียงนี้ได้ จึงเรียกว่า Photoacoustic NDIR

ที่มา เอกสารของ Sensirion

ถ้ามีโมเลกุลของ carbon dioxide มาก ก็จะสามารถตรวจจับเสียงนี้ได้มาก และเนื่องจากเสียงกระจายทุกทิศทาง ดังนั้นจะวาง microphone ไว้ตรงไหนใน measurement chamber ก็ได้ ทำให้ตัวตรวจวัดแบบนี้มีขนาดเล็กกว่าแบบ Transmissive NDIR เช่น carbon dioxide sensor (SCD4x) ของ Sensirion ที่มีขนาดเล็กกะทัดรัด

ที่มา data sheet ของ Sensirion

ที่มา

Posted on by — Leave a comment

Machine Learning (ML) คืออะไร

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

ทำไมต้องใช้ Machine Learning

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

Machine Learning เรียนรู้อย่างไร

เพื่อให้เห็นภาพชัดขึ้น ลองเปรียบเทียบการเรียนรู้ของ มนุษย์กับ machine ว่าต่างกันอย่างไร เพื่อให้เข้าใจง่าย ๆ จะขออธิบายดังนี้ มนุษย์เรียนรู้โดยการ รวบรวมข้อมูล -> มองหารูปแบบ -> คิดหาเหตุผล และตั้งสมมติฐาน -> สร้าง model และ parameter จากสมมติฐาน -> ทดสอบ model นั้น และวนทำซ้ำไปเรื่อย ๆ จนกว่าจะได้ผลการทดสอบเป็นที่น่าพอใจ แล้วจึงนำ model นั้นมาตั้งเป็น ทฤษฎี และนำไปใช้ ในขณะที่ machine learning นั้น ทำคล้าย ๆ กัน เพียงแต่ไม่มีขั้นตอนของการหาเหตุผลเท่านั้นเอง สิ่งที่ได้ก็เป็น model และ parameter ที่ทดสอบจนพอใจแล้วเท่านั้น

เปรียบเทียบการเรียนรู้ของมนุษย์(ซ้าย) กับ machine (ขวา)

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

สรุป

ถ้าเราเข้าใจตรงกัน ผู้อ่านคงพอเดาได้ว่า การศึกษา machine learning นั้น ส่วนใหญ่จึงเป็นการศึกษาเกี่ยวกับการมองหารูปแบบของข้อมูล และการกำหนดหลักการในการสร้าง model และ parameter นั่นเอง แล้วเราจะได้มาดูเรื่องนี้ในโอกาสต่อไป

Posted on by — Leave a comment

RP2040 (microcontroller) คืออะไร

RP2040

คือ microcontroller ของค่าย Raspberry Pi ออกแบบโดย Raspberry Pi บนสถาปัตยกรรม ARM Cortex-M0+ รองรับการเขียนโปรแกรม สำหรับมือสมัครเล่น (ที่ไม่ใช่เล่น ๆ ) นิยมใช้อย่าง MicroPython และรองรับการเขียนโปรแกรมระดับมืออาชีพ โดยรองรับ C/C++ ด้วย จุดเด่นของ microcontroller ตัวนี้คือประสิทธิภาพสูง โดยเป็น dual-core ARM Cortex-M0+ 32bit ทำงานที่ความถี่ 133 MHz มี Flash ขนาด 2MB และ SRAM ขนาด 264KB ซึ่งสูงมากเมื่อเทียบกับรุ่นพี่เก่าแก่อย่าง Arduino UNO ที่ใช้ ATmega328p ทำงานที่ความถี่ 16MHz มี Flash ขนาด 32K และ SRAM ขนาด 2K ที่สำคัญคือราคาไม่สูงมาก และมีหลายบริษัทฯได้พัฒนาบอร์ดของตัวเองโดยใช้ chip ตัวนี้ บริษัทที่เป็นที่รู้จักกันดีเช่น Arduino, Adafruit, Sparkfun และอื่นๆ อีกมาก ที่สำคัญอีกอย่างคือมีการ port TensorFlow Lite Micro ไว้รองรับงาน Machine Learning ด้วย

ถือว่าเป็น microcontroller ที่น่าสนใจมาก ๆ ทั้งความที่เป็น dual-core ARM และมีการ port TensorFlow Lite Micro มาให้ใช้ด้วย

ที่มา

https://www.raspberrypi.com/products/rp2040/

Posted on by — Leave a comment

Differential Signaling vs Single-ended Signaling ต่างกันอย่างไร

Differential signaling

เป็นการส่งสัญญาณผ่านสายสัญญาณ 2 เส้น โดยที่ทั้งสองเส้นนั้นมีขนาดของสัญญาณเท่ากัน แต่ขั้วตรงกันข้าม เช่น ในขณะที่เส้นหนึ่งเป็น 5v อีกเส้นจะเป็น -5v ข้อดีของระบบนี้คือ สามารถกำจัดสัญญาณรบกวนที่เป็น common-mode (สัญญาณที่ทั้งสองสายมีเหมือนกันทั้งขนาดและขั้ว) ได้ดี เช่น สัญญาณรบกวนจากคลื่นแม่เหล็กไฟฟ้าในสายส่งสัญญาณ เนื่องจากสัญญาณที่เราต้องการส่งนั้นมีทิศทางตรงข้ามกัน แต่สัญญาณรบกวนที่เข้ามาในสายสัญญาณนั้น ก็จะเข้าเหมือนกันทั้งสองสาย จึงสามารถกำจัดได้ง่าย โดยใช้ differential amplifier ทำให้ระบบ differential signaling ทนต่อสัญญาณรบกวนได้ดี และทำให้ส่งสัญญาณได้ไกล และเร็ว

Single-ended Signaling

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

อ้างอิง