ตอนที่ 10 นาฬิกาบน KidBright เปิดปิดไฟตามเวลา

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

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

 

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

     การตั้งเวลาบอร์ด 

   การเขียนโปรแกรม

    แสดงค่าวันและเวลาปัจจุบัน

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

    จากคำสั่งตอนแรกเราให้แสดงค่าวันและเวลาปัจจุบันบนจอแสดงผลแอลอีดีก่อน (LED 16x8 Scroll...Date/Time) แล้วเก็บข้อมูลชั่วโมงปัจจุบันไว้ในตัวแปร hour (set hour to Hour) แสดงผลค่าที่เก็บไว้อีกทีบนจอเพื่อตรวจสอบ (LED 16x8 Scroll...hour) กำหนดเงื่อนไขให้เปิดใช้งานอุปกรณ์เมื่อเลขชั่วโมงอยู่ระหว่าง 7-17 จึงใช้คำสั่ง if..do.. เปรียบเทียบเวลาชั่วโมงปัจจุบันกับเงื่อนไข หากเวลาปัจจุบันอยู่ในช่วง 7-17 ให้สั่งสัญญาณสถานะ ON ไปที่พอร์ต OUT1 ซึ่งเราจะดึงสัญญาณนั้นไปทริกให้ไฟแอลอีดีสว่างขึ้น ทีนี้เรามาลองดูผลลัพธ์กัน

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

        โดย นาที = (ชั่วโมง x 60) + นาที  

แล้วสร้างเงื่อนไขเวลาที่ต้องการ จะได้โปรแกรมดังภาพด้านล่าง (นาทีที่ระบุในเงื่อนไขโปรแกรมเป็นค่าที่คำนวณจาก 7.00-17.00 น.)

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

ครั้งหน้าพบกันใหม่นะจ๊ะ ขอเวลาไปคิดมุกเล่นกับบอร์ดแปร๊บ...

#Kidbright #Kidbright คืออะไร #Kidbright ทำอะไรได้บ้าง

ตอนพิเศษ (2) การสร้างสื่อการเรียนรู้จากบอร์ด KidBright เรื่องอัตราทดเฟืองและการเปลี่ยนแปลงความเร็ว

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

    ภาพด้านล่างคือโค้ดทั้งหมดจะเห็นว่าตัวโค้ดแบ่งเป็นโปรแกรมหลัก (ที่มีคำสั่ง Forever ครอบอยู่) และฟังก์ชันย่อยที่ชื่อ VELO โดยโปรแกรมหลักจะทำหน้าที่แสดงค่าความเร็วเฉลี่ยบนจอ OLED ขณะที่ฟังก์ชัน VELO ใช้คำนวณค่าได้จากเซ็นเซอร์มาลองดูรายละเอียดกัน

    ขออธิบายตามลำดับการทำงานของโปรแกรมเลย จากโปรแกรมหลัก เราตั้งค่าตัวแปร count กับ read เป็น 0 จากนั้นให้จอ OLED แสดงข้อความขนาดใหญ่ว่า "Speed" ที่ตำแหน่ง (1,1) (column, row) แล้วเรียกฟังก์ชัน VELO มาใช้งาน

    ที่ฟังก์ชัน VELO จะเข้าสู่การวนลูปการทำงานไปเรื่อย ๆ เมื่อค่า count < 10 ด้วยคำสั่ง Repeat while... (จำได้เนาะว่าเมื่อตอนต้นเราตั้งค่า count = 0 ดังนั้นตอนนี้ count < 10) ลำดับต่อไปโปรแกรมเลยอ่านค่าจาก Encoder ด้วยคำสั่ง Pulse capture read ตรงนี้ตั้งค่าให้อ่านจากพอร์ต IN1 ตามตำแหน่งที่ได้ต่อเซ็นเซอร์ไว้ก่อนหน้านี้ ค่าที่อ่านได้จะวัดจากขาลงของสัญญาณของสองลูกพัลส์มีหน่วยเป็นไมโครวินาทีเท่ากับว่าเราจะทราบว่าคลื่นพัลส์มีความยาวเท่าไหร่ก็เก็บค่าไว้ในตัวแปร pulse

   การหาค่าความเร็วในหน่วยรอบต่อนาทีเราต้องแปลงค่าที่อ่านได้ (pulse) อีกทีหนึ่ง จากที่เราทราบว่า จานนับความเร็วรอบที่เราใช้มี 20 ช่อง ดังนั้นเมื่อหมุนครบ 1 รอบเราจะได้ค่าเวลารวม (20 x pulse) ไมโครวินาที หรือ (20 x pulse) ไมโครวินาทีต่อรอบ เมื่อต้องการค่าในหน่วยรอบต่อนาที (rpm) ก็ทำการแปลงหน่วยซะ จะได้ว่า

    Speed (rpm) = (1 x 60)/(20 x pulse x 10^-6)

ใช้คำสั่ง Set speed = ....ใส่ค่าตามสมการด้านบน

    ลำดับต่อมาเราเก็บค่าความเร็วที่คำนวณแล้วไว้ในตัวแปร Read เดิมตัวแปรนี้มีค่าเป็น 0 ดังนั้นเมื่อจบลูป while รอบแรกค่า Read = Speed คำสั่งต่อมาในลูปโปรแกรมจะตั้งค่า count = count+1 เพื่อบอกโปรแกรมว่าตอนนี้ค่า count เปลี่ยนเป็น 1 แล้ว ดังนั้นเมื่อวกกลับไปเช็คค่า count ที่คำสั่ง while โปรแกรมก็จะอ่านค่าและคำนวณความเร็วอีกครั้งเพราะค่า count ยังน้อยกว่า 10 การทำงานครั้งที่สองนี้ค่า Read จะเป็นค่าสะสมของ Speed ที่อ่านได้ครั้งที่สอง และค่า count ก็จะเปลี่ยนไปด้วยวนไปอย่างนี้จนสะสมครบ 10 ค่า ครั้งนี้ count = 10 ไม่ตรงตามเงื่อนไข while จึงออกจากลูป 

    ค่าความเร็วเฉลี่ยได้มาจากค่า Read ซึ่งเป็นผลรวมของค่าความเร็ว 10 ค่า ใช้คำสั่ง Set average = เพื่อเก็บค่าเฉลี่ยความเร็วไว้ที่ตัวแปรที่ชื่อว่า average จึงจบการทำงานของฟังก์ชัน VELO

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

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

    เมื่อจบโปรแกรม KidBright จะเริ่มทำงานใหม่จากคำสั่งแรกอีกครั้ง และทุกครั้งที่เริ่มวนกลับมา ตัวแปร count กับ Read ที่ใช้เก็บค่าสะสมในฟังก์ชันจะกลับมาเป็น 0 ทุกครั้งที่เริ่มต้นใหม่ 

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

ข้อสังเกต ไม่ว่าจะเอาเฟืองกี่ตัวมาต่อเชื่อมกัน

• เฟืองที่อยู่ติดกันจะหมุนในทิศทางตรงกันข้าม

• เฟืองขนาดใหญ่กว่าจะหมุนด้วยความเร็วรอบที่ช้ากว่า

• เฟืองที่มีขนาดเท่ากันจะหมุนด้วยความเร็วรอบเท่ากัน

วันนี้เอาไว้แค่นี้ก่อนน้อ...

ตอนพิเศษ (1) การสร้างสื่อการเรียนรู้จากบอร์ด KidBright เรื่องอัตราทดเฟืองและการเปลี่ยนแปลงความเร็ว

     สวัสดีทุกท่าน มาคราวนี้ขอเป็นตอนพิเศษเนื่องจากได้รับคำขอมาจากทีมงาน Krukid จากเนคเทคจ้า ด้วยความเดิมเมื่อปีที่แล้วที่ผู้เขียนกับน้องอีกคนที่เป็นวิศวกรประจำ Fablab ในสถานศึกษาที่ทำงานอยู่เกิดฮึกเหิมอยากลองลงประกวดสิ่งประดิษฐ์ที่สื่อการสอนที่พัฒนาจากบอร์ด KidBright ในงาน Krukid 2019 ที่จัดขึ้นโดยเนคเทคที่สามย่านมิตรทาวน์ แล้วทีนี้บังเอิญว่าผลงานก็พอเป็นที่สนใจบ้าง ทางทีมงานเค้าเห็นว่าสื่อตัวนี้น่าจะเป็นประโยชน์กับคนอื่น ๆ ด้วยเลยขอตัดบางส่วนของผลงานที่เป็นเรื่องเกี่ยวกับการเปลี่ยนความเร็วการหมุนด้วยเฟืองมาบันทึกไว้ตรงนี้ให้ได้อ่านกัน เริ่มต้นเลยขอให้ทฤษฎีเรื่องอัตราทดเฟืองซักนิดนึงก่อนแล้วค่อยไปดูการสร้างชุดสื่อการสอนกัน บทความนี้ก็เลยอาจจะยาวหน่อยนะ 

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

เฟืองตรง (spur gear) นับเป็นเฟืองพื้นฐานที่เรียกชื่อตามรูปแบบของเฟืองที่เป็นทรงกระบอกตรงและมีฟันเฟืองที่ตรงไปตามแนวแกนของเพลา นอกจากเฟืองตรงแล้วยังมีเฟืองชนิดอื่น ๆ ที่มีรูปร่างที่ต่างออกไปอีก เช่น เฟืองเฉียง (helical gear) เฟืองดอกจอก (bevel gear) เฟืองสะพาน (rack and pinion) เป็นต้น การกำหนดขนาดของเฟืองที่นิยมใช้มี 2 ระบบคือระบบอังกฤษ (Imperial) ที่บอกขนาดเป็นนิ้วและระบบเอสไอ (SI) ที่บอกขนาดเป็นโมดูลและมิลลิเมตร ในบทความนี้จะอธิบายเฉพาะเฟืองตรง และใช้หน่วยในระบบเอสไอซึ่งทุกคนน่าจะคุ้นเคยกันมากกว่า

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

1. เฟืองที่ใช้เป็นระบบเดียวกัน ซึ่งจะกำหนดขนาดมุมและความสูงของฟันเฟืองเป็นมาตรฐานเดียวกัน 

2. มีขนาดของฟันเฟืองที่เท่ากัน ในระบบเอสไอ จะใช้โมดูล (module) เป็นดัชนีในการบอกขนาดของฟันเฟือง เฟืองที่นำมาใช้ด้วยกันได้ต้องมีโมดูลเท่ากัน

โมดูล (m) เป็นอัตราส่วนระหว่างเส้นผ่านศูนย์กลางพิตช์ (Dp หน่วยมิลลิเมตร) กับจำนวนฟันบนเฟือง (n) 

m = Dp/n

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

Speed2/Speed1 = Dp1/Dp2 

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

อัตราทดเฟือง = n2/n1 = Dp2/Dp1 = D2/D1 = Speed1/Speed2  

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

1.   มอเตอร์ 12V DC ขนาดเพลามอเตอร์ 6 มม. เป็นเพลารูปตัว D

2. Switching Power Supply 12V. กระแสไม่ต่ำกว่า 2A.

3. เฟืองขนาดใหญ่และเล็กที่มีโมดูลเท่ากัน (มีแบบให้โหลด)

4. สกรูหัวเทเปอร์ขนาด M6 ยาว 55 มม. มาขัดแต่งเป็นเพลา

5. ลูกปืน สำหรับเพลา 6 มม. สกรู M3 น็อต M3/M6 น็อตล็อค M6

6. แผ่นไม้หรืออะคลิลิคหนา 10 มม.เพื่อใช้ทำแท่นยึดมอเตอร์และเฟือง (ตามแบบ)

7. บอร์ด Kidbright V1.3 หรือสูงกว่า 

8. Photoelectric Encoder 1 ตัว จานนับความเร็วรอบแบบ 20 ช่อง 2-6 ชิ้น 

9. OLED display 128X64 pixel ขนาด 1.3 นิ้ว 

10. วงจรลดแรงดันไฟฟ้า 1.5-35V. 3A. (LM2596 DC step down) ใช้ปรับลดแรงดันเข้ามอเตอร์เพื่อเพิ่มหรือลดความเร็ว อาจดัดแปลงใส่ตัวต้านทานปรับค่าได้ (potentiometer) ขนาด 20 กิโลโอห์มใส่แทนปุ่มปรับแรงดันที่ตัววงจรลดแรงดันก็ได้เพื่อความสะดวกในการใช้งาน หรืออาจใช้ตัวต้านทานปรับค่าได้ในวงจรจ่ายไฟมอเตอร์เลยโดยไม่ใช้วงจรลดแรงดันก็ได้แต่ความเร็วมอเตอร์อาจจะไม่เสถียร 

11. สายไฟและสายสัญญาณต่าง ๆ 

12. ไม้บรรทัด เทปกาวสองหน้า เทปกาว ปืนกาว ฯลฯ

การสร้างสื่อการสอนจะแบ่งออกเป็นฝั่งฮาร์ดแวร์กับซอฟแวร์นะ เอาฝั่งฮาร์ดแวร์ก่อน

วิธีสร้าง

1. ใช้เครื่องพิมพ์สามมิติสร้างเฟืองขนาด 40 มิลลิเมตร และขนาดอื่น ๆ พร้อมกับ spacer และแป้นยึดเฟืองจำนวนตามที่ต้องการ เลือกโหลดเฟืองได้ตามใจจากลิงค์นี้ Gears.STL files 

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

3.  นำสกรูหัวเทเปอร์ขนาด M6 ยาว 55 มม. จำนวน 5-6 ตัว มาขัดแต่งเป็นเพลารูปตัว D ขนาดรูปร่างเหมือนกับรูที่เฟือง

    4. ติดตั้งลูกปืนและเพลาเฟืองบนแป้นยึดเฟือง ใช้น็อต M6 ยึดเพลาเข้ากับลูกปืน แล้วนำจานนับความเร็วรอบมาติดที่ปลายสกรูด้วยปืนกาว 

    5. ติดตั้งเฟืองขนาด 40 มม.บนมอเตอร์ ส่วนเฟืองขนาดอื่นๆ ให้นำมาเรียงบนแท่นมอเตอร์ตามต้องการ สอดเพลาที่อยู่บนแป้นเฟืองมาจากด้านหลัง ใส่ spacer แล้วตามด้วยเฟืองทางด้านหน้า หมุนเฟืองให้รูเฟืองที่เป็นรูปตัว D พอดีกับเพลา ล็อคเฟืองเข้ากับเพลาด้วยน็อตล็อคขนาด M6 แล้วใช้สกรู M3 ยึดแป้นเฟืองให้ติดกับแท่นมอเตอร์ กะให้เฟืองแต่ละตัวมีระยะฟันเฟืองระหว่างกันที่ไม่แน่นหรือหลวมเกินไป ทำเสร็จแล้วจะคล้าย ๆ กับภาพข้างล่าง (แต่ไม่ต้องงงนา..ภาพนี้เฟืองคนละแบบกันนะจ๊ะแต่ติดตั้งเหมือนกันจ้ะ)

    6. สร้างหัววัดความเร็วโดยติด Photoelectric Encoder บนปลายไม้บรรทัดด้วยปืนการหรือกาวสองหน้าแบบหนา ที่เซ็นเซอร์ให้ต่อสายสัญญาณจาก pin DO เข้า IN1 บนบอร์ด KidBright และใช้ไฟเลี้ยงเซ็นเซอร์จากบอร์ด KidBright pin 5V และ GND ให้เซ็นเซอร์ ส่วนไฟเลี้ยงบอร์ด KidBright จะต่อเข้าจากแหล่งจ่ายไฟภายนอกขนาด 5V. หรือจะใช้ไฟจากพอร์ต micro USB ก็ได้ ส่วนสุดท้ายจอ OLED ให้ต่อสายออกมาจากทุก ๆ pin ของจอเรียงเข้าพอร์ต I2C ตามชื่อที่ระบุบน pin ดูการต่อตามภาพด้านล่าง

    7. มอเตอร์ที่ติตตั้งไว้แล้วบนแท่น ต่อไฟเข้ามอเตอร์โดยใช้อุปกรณ์ดังที่กล่าวไว้ก่อนหน้านี้ ดังภาพ

จบแล้วสำหรับส่วนแรก ตอนหน้าจะมาดูโปรแกรมกัน ไม่น่าจะยาวล่ะนะ รอแปร๊บบบบ จะมาโพสต์ต่อ

ตอนที่ 9 วัดอุณหภูมิกับ KidBright องศาเซลเซียสหรือองศาฟาเรนไฮต์

    สวัสดีอีกครั้งทุกคน หายไปหลายวันเพราะออฟฟิศซินโดรมปวดคอปวดหัวอย่างมาก ตาลายมึนหัวตามมาอี๊ก...เลยหนีไปเลี้ยงสัตว์ปลูกต้นไม้กินยานอน  แต่ก็กลับมาแล้วอะนะ

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

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

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

C/5  =  (F-32)/9

      F  =  9C/5 + 32

     F  =  4.5C+32

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

    ในการเขียนโปรแกรมให้เครื่องคำนวณก่อนอื่นต้องเก็บค่าจากเซ็นเซอร์ไว้ในตัวแปรตัวแปรนึง ในที่นี้ให้เป็น TempC (อุณหภูมิในหน่วยองศาเซลเซียส) แล้วเดี๋ยวจะเขียนบล็อกคำสั่งที่เป็นสมการเพื่อหาค่า TempF (อุณหภูมิในหน่วยองศาฟาเรนไฮต์) ดังนั้นต้องสร้างตัวแปรก่อน ให้ไปที่แถบเมนู Variables แล้วกด Create variable...ดังภาพด้านล่าง 

    เราจะสร้างตัวแปรมา 2 ตัว คือTempC (อุณหภูมิในหน่วยองศาเซลเซียส) และ TempF (อุณหภูมิในหน่วยองศาฟาเรนไฮต์) ตามวิดีโอนะ

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

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

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

1. แสดงข้อความส่วนหัวว่าจะเป็นการวัดอุณหภูมินะ

2. อ่านค่าอุณหภูมิแล้วเก็บในตัวแปร TempC แล้วคำนวณค่าอุณหภูมิในหน่วยองศาฟาเรนไฮต์

3. รอค่าจากสวิตช์ S1 หรือ S2 

4. ใส่เงื่อนไขถ้ากด S1 แสดงค่าองศาเซลเซียส แต่ถ้ากด S2 ให้แสดงค่าองศาฟาเรนไฮต์ (ให้รอการกดปุ่มก่อน)

5. วนกลับไป 1 อันนี้คือคำสั่ง Forever ไง

ลองเขียนบล็อกดูแล้วปรับลำดับนิด ๆ หน่อย ๆ มาดูภาพโปรแกรมเต็ม ๆ กัน

    จากโปรแกรมของเราตอนแรกเราจะให้จอแสดงข้อความว่า DegreeC หรือ DegreeF แล้วเข้าสู่คำสั่ง Repeat while (เอามาจากแถบเมนู Loop) บล็อกนี้คือการสั่งให้อ่านค่าอุณหภูมิจากเซ็นเซอร์แล้วเก็บข้อมูลอุณหภูมิในหน่วยองศาเซลเซสไว้ในตัวแปร TempC ตามด้วยการคำนวณอุณหภูมิในหน่วยองศาฟาเรนไฮต์เก็บในตัวแปร TempF แล้วจึงแสดงข้อความว่า S1 or S2 วนอยู่อย่างนั้นในกรณีที่ไม่มีการกด Switch 1 และ Switch 2 เป็นการรอค่าจากผู้ใช้งานนั่นเอง เมื่อมีการกดสวิตช์ซักตัวนึงจะออกจากลูปแล้วเข้าสู่บล็อก if...do... เพื่อแสดงค่าตามเงื่อนไขที่กำหนดไว้

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

#Kidbright #Kidbright คืออะไร #Kidbright ทำอะไรได้บ้าง

ตอนที่ 8 ต่อหลอด LED กับพอร์ตเอาต์พุตจาก KidBright

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

    หลอดไฟ LED เราจะเอามาต่อคู่กับตัวต้านทานขนาด 220 โอห์มเพื่อใช้งานเป็นเอาท์พุต แต่ถ้าหาตัวต้านทานขนาดเท่านี้ไม่ได้ก็ใช้ตัวที่มากกว่าเช่น 240, 250 โอห์มแทนก็ได้ สายจัมเปอร์จะนำมาต่อหลอดไฟเข้ากับบอร์ด แต่บอร์ด KidBright ที่ได้มาจะยังไม่มีพินไว้เสียบสายต้องบัดกรีก้างปลาลงบนบอร์ดก่อนนะ ก่อนบัดกรีก็ให้นับช่องดูแล้วหักก้างปลาตามจำนวนที่ต้องการแล้วใช้หัวแร้งบัดกรีก้างปลาลงบนบอร์ด สำหรับเด็ก ๆ ถ้าไม่ชำนาญอย่าทำเองให้ผู้ใหญ่ทำให้ดีกว่านะจ๊ะ หัวแร้งบัดกรีมันร้อนมากจะลวกมือเอาได้ง่าย ๆ และตัวสุดท้ายที่จำเป็นคือบอร์ดทดลอง เอามาไว้เชื่อมต่อตัวต้านทาน หลอดไฟ และสายไฟ กับบอร์ด KidBright

ภาพด้านล่างแสดงจุดบัดกรีก้างปลาลงบอร์ด

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

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

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

ภาพต่อจริงจะเป็นอย่างงี้

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

อันดับแรกดึงบล็อกคำสั่ง Write Output 1 Status Off ออกมา

เขียนโปรแกรมตามนี้

เรียบร้อย มาทดลองกันเลย ถ้าเราเอามือปิดเซ็นเซอร์แสงให้ระดับแสงน้อยกว่า 30% ไฟต้องติดนะ ดูผลลัพธ์ได้จากวิดีโอด้านล่าง

จะเห็นว่าไม่ว่าเราจะใช้ USB หรือ OUT1 ไฟก็ติดเหมือนกันแตกต่างกันที่อุปกรณ์ที่นำมาเชื่อมต่อ จริง ๆ แล้วพอร์ต USB อาจจะสะดวกกรณีที่เรามีอุปกรณ์ไฟฟ้าที่ใช้ไฟ 5V แล้วต้องการแค่สั่งเปิดหรือปิดใช้งานเท่านั้น แต่การใช้ OUT1 จะสามารถใช้เป็นการส่งสัญญาณ 0/1 (LOW/HIGH) ไปทริกชุดอุปกรณ์ภายนอกอื่น ๆ ให้ทำงานตามที่เราวางแผนไว้ได้ ในรายละเอียดถ้ามีโปรเจ็คแบบไหนที่ใช้งานลักษณะหลังจะเอามาให้ดูกันอีกทีนะ วันนี้เอาแค่นี้ก่อนดีกว่า...

#Kidbright #Kidbright คืออะไร #Kidbright ทำอะไรได้บ้าง

ตอนที่ 7 KidBright เปิดปิดไฟได้

    ตอนนี้เราลองมาจำลองสถานการณ์การใช้งานกัน สมมติใช้เซ็นเซอร์แสงวัดค่าแสงในห้อง ถ้าแสงน้อยให้เปิดไฟ ถ้าแสงมากให้ปิดไฟ ตอนนี้เราจะยังใช้หลอดไฟมาต่อกับบอร์ด เริ่มต้นลองเขียนโปรแกรมว่า ถ้าแสงน้อยให้แสดงผลบนจอแอลอีดีว่า Turn on และถ้าแสงน้อยให้แสดงผลว่า Turn off งานนี้ต้องใช้ if...do...อีกแล้ว ลองดูภาพด้านล่างนะ

    

    จากภาพบล็อกคำสั่งเราต้องการให้จอแอลอีดีแสดงค่าแสงที่วัดได้ รอจนแสดงค่าครบแล้วใช้คำสั่ง if...do...ตรวจสอบค่าแสง ถ้าค่าแสงน้อยกว่า 30% (if Light Level sensor < 30)ให้แอลอีดีแสดงผลว่า "Turn on"  (LED 16x8 Scroll "Turn on") นอกเหนือจากนี้ (else)  ให้แอลอีดีแสดงผลว่า "Turn off"  (LED 16x8 Scroll "Turn off") คำสั่ง Wait LED matrix ready ใช้รอเพื่อให้จอแอลอีดีแสดงผลจนหมดแล้วทำงานต่อไป หากเราเขียนโปรแกรมตามนี้จะได้ผลลัพธ์ตามวิดีโอด้านล่าง

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

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

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

 

    ก่อนอื่นเราต้องปรับโปรแกรมเราให้สามารถสั่งการพอร์ต USB ได้ก่อน ให้ไปที่เมนู I/O ในแถบเครื่องมือ ลากบล็อก Write USB status OFF ออกมา 2 บล็อกเลย

    

        จากนั้นสร้างโปรแกรมตามภาพด้านล่าง ในบล็อก Write USB status OFF ตรงที่เป็น OFF สามารถกดเปลี่ยนให้เป็น ON ได้ คำสั่งนี้หมายถึงให้ปิดหรือเปิดการจ่ายกระแสไฟที่พอร์ต USB นั่นเอง

    สังเกตว่าโปรแกรมใหม่นี้คล้ายกับตัวเดิมที่เขียนไว้เพียงแต่แทรกบล็อกคำสั่ง Write USB status ON และ Write USB status OFF ให้เปิดและปิดไฟเข้าไปก่อนหน้าการแสดงผลบนจอแอลอีดี บางคนอาจจะสงสัยว่าจะเอาบล็อกคำสั่งนี้ใส่หลังจากบล็อกคำสั่งให้จอแอลอีดีแสดงผลได้ไหม คำตอบคือสามารถทำได้ผลลัพธ์แค่จะมีการเปลี่ยนแปลงลำดับการทำงานของโปรแกรมเพียงเล็กน้อย ลองทำแล้วสังเกตดูนะจ๊ะ ตอนนี้ลองดูผลจากโปรแกรมด้านบนจากวิดีโอนี้ก่อน

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

    ครั้งหน้าเปลี่ยนเป็นอะไรดี อุบไว้ก่อนน้า.....

#Kidbright #Kidbright คืออะไร #Kidbright ทำอะไรได้บ้าง