Archive
ฝึกการเขียนโปรแกรม ด้วย Robo MIND ภาค #5
จาก หัวข้อ ฝึกการเขียนโปรแกรม ด้วย Robo MIND ภาค #4 คำสั่งตรวจจับสิ่งรอบตัวหุ่นยนต์ / Sensing the environment เราได้คำสั่งเพิ่มเติมในส่วนของการ ตรวจจับสิ่งรอบตัว ซึ่งสิ่งรอบตัวประกอบด้วย ตรวจสิ่งกีดขวาง ตรวจ Beacon ตรวจสีพื้น เท่าที่เราได้ทำ แบบฝึกใาเราได้ใช้คำสั่งในการตรวจสอบสิ่งกีดขวางมาแล้วคือ frontIsClear ซึ่งเป็นกำแพง ในฉาก ต่อไปเราจะเพิ่มเติมก็คือ ในกลุ่ม ตรวจสีพื้น เช่น frontIsWhite ซึ่งสีพื้นจะมีได้ก็ต้องการมีการระบาย ลงไปด้วยตัวหุ่นเองหรือมีในฉากนั้น ๆ
ในแบบฝึกนี้เราจะตั้งโจทย์เพิ่มเติมจากโจทย์ทีแล้วว่า นอกจากเราจะวิ่งไปอย่างเดียวเราก็ ระบายสีลงบนทางเที่เราวิ่งไปด้วย และเพิ่มตเติมก็คือเราจะไม่วิ่งไปทับทางเดิมที่ระบายไว้
จาก Code เดิมยกมาจากตัวอย่างเดิม ดังด้านลาง
repeat{
if(frontIsObstacle) { # ตรวจดูว่าด้านหน้าไปได้ไหมถ้ามี ให้ สุ่ม
if(flipCoin){
right
}else{
left
}
}else { #ถ้าไม่มีก็ สั่งเดิน 1 ครั้ง
forward(1)
}
}
เมื่อเราปรับปรุงตามโจทย์และเติมลงไป จะได้ดังนี้
repeat{
if(frontIsObstacle) { # ตรวจดูว่าด้านหน้าไปได้ไหมถ้ามี ให้ สุ่ม
if(flipCoin){
right
}else{
left
}
}else { #ถ้าไม่มีก็ สั่งเดิน 1 ครั้ง
paintWhite() # วางแปลง
forward(1) # เดินหน้า 1 step
}
stopPainting() # ยกแปลงทาสี คือหยุดทา
}
แล้วลอง Run ดู
ซึ่งเห็นแล้วว่าทำงานได้ อย่างที่อยากให้ทำ แต่ก็ดูแปลก ๆ จะเห็นว่าหุ่นเรา วางแปลง วิ่ง ยกแปลง แบบนี้เรายังไม่อยากได้ ถ้าเรา เอา paintWhite() ไปอยู่ด้านบน เลยจะเป็นอย่าไร ขั้นตอนมันจะกลายเป็นว่า
วางแปลง ตรวจสอบด้านหน้า หมุน เดิน วนไปบรรทัดตรวจสอบด้านหน้า สุดท้ายยกแปลง แบบนี้ จะได้ Code ดังนี้
paintWhite() # วางแปลง
repeat{
if(frontIsObstacle) { # ตรวจดูว่าด้านหน้าไปได้ไหมถ้ามี ให้ สุ่ม
if(flipCoin){
right
}else{
left
}
}else { #ถ้าไม่มีก็ สั่งเดิน 1 ครั้ง
forward(1) # เดินหน้า 1 step
}
}
stopPainting() # ยกแปลงทาสี คือหยุดทา
ทอดลอง ทำงานก็จะได้ ดัง Videoเหมือนด้านลาง
ก็เห็นว่าลักษณะการเคลื่อนที่ของ หุ่นทำได้ไวขึ้นและทาทีตามต้องการ มีใครทำได้ดีกว่านี้มั้ย
มีคำถามทิ้งท้ายว่าหากต้องการที่จะไม่ให้หุ้นต้อง ระบายทับในพื้นที่เขาระบายแล้วทำอย่าง แบบฝึกหน้าจะมาเฉลอยนะครับ ทดลองทำดูก่อนนะครัย
s.teerapong@gmail.com
ฝึกการเขียนโปรแกรม ด้วย Robo MIND ภาค #4 คำสั่งตรวจจับสิ่งรอบตัวหุ่นยนต์ / Sensing the environment
สำหรับหัวข้อนี้ก่อน ตัวอย่างต่อไปผมขอเพิ่มเติใ คำสั่งในหมวด ของการตรวจจับสิ่งแวดลอมรอบๆ ตัวหุ่นยนหรือ Sensing the environment ว่ามีกี่คำสั่งอะไรบ้างเพื่อให้เราสามารถทำ Algorithm หุ่นของเราฉลาดขึ้น
1. frontIsClear
คำสั่ง: คืนค่า true ถ้าด้านหน้าว่าง, false ถ้ามีสิ่งกีดขวาง
English: Returns true if the path directly in front of the robot is clear, false otherwise.
ตัวอย่าง / Example
if frontIsClear {
forward(1)
}
หุ่นยนต์จะเดินหน้า 1 ก้าวถ้าทางว่าง
2. frontIsObstacle
คำสั่ง: ตรวจว่าด้านหน้ามีสิ่งกีดขวางหรือไม่
English: Returns true if there is an obstacle directly in front of the robot.
ตัวอย่าง / Example
if frontIsObstacle {
left
)
ถ้ามีสิ่งกีดขวางตรงหน้า → หันซ้าย3. frontIsBeacon
คำสั่ง: ตรวจว่ามี Beacon (สัญญาณเป้าหมาย) อยู่ด้านหน้าหรือไม่
English: Returns true if a beacon is directly in front of the robot.
ตัวอย่าง / Example
if frontIsBeacon{
paintWhite # Mark as reached
}
ถ้าเจอสัญญาณ beacon → ระบายสีพื้นเพื่อแสดงว่า “ถึงเป้าหมายแล้ว”4. Sensing on other sides
นอกจากด้านหน้าแล้ว ยังสามารถตรวจซ้ายและขวาได้เหมือนกัน
Similar commands exist for left and right directions:
leftIsClear
rightIsClear
leftIsObstacle
rightIsObstacle
leftIsBeacon
rightIsBeacon
ตัวอย่าง / Example
if rightIsClear {
right
}else{
left
}
ถ้าทางขวาโล่ง → เลี้ยวขวา, ถ้าไม่โล่ง → หันซ้ายแทน5. Ground Color Sensing
ตรวจสีของพื้นด้านหน้า ซ้าย หรือขวา
Checks for the color of the ground directly ahead or beside the robot.
คำสั่ง / Commands:
frontIsWhite
frontIsBlack
leftIsWhite
leftIsBlack
rightIsWhite
rightIsBlack
ตัวอย่าง / Example
if frontIsBlack() then
backward(1)
else
forward(1)
end
ถ้าพื้นด้านหน้าเป็นสีดำ → ถอยหลัง 1 ก้าว
ถ้าไม่ใช่สีดำ → เดินหน้าสรุปภาพรวม
| กลุ่ม | ตัวอย่างคำสั่ง | หน้าที่ | ค่าที่คืนกลับ (Return) |
|---|---|---|---|
| ตรวจสิ่งกีดขวาง | frontIsClear, rightIsObstacle | ตรวจว่าทางว่างหรือมีสิ่งขวาง | true / false |
| ตรวจ Beacon | frontIsBeacon | ตรวจว่ามีสัญญาณเป้าหมายอยู่ตรงหน้า | true / false |
| ตรวจสีพื้น | frontIsWhite, leftIsBlack | ตรวจสีของพื้นในทิศต่าง ๆ | true / false |
ยาวนิสหนี่ง ครับอยากให้เห็น ภาพรวมของคำสั่งที่ใช้ในการตรวจสอบ สิ่งแวดล้อมของหุ่นซึ่งก็มีเท่านี้เลือกใช้ตามสถานการได้ เสริมความฉลาดของหุ่นเรา …
s.teerapong@gmail.com
ฝึกการเขียนโปรแกรม ด้วย Robo MIND ภาค #3 ว่าด้วยเรื่องการ สุ่ม (Random)
ในการโปรแกรม เราจะมี Function หรือ ตัวแปรหนึ่งเพื่อเป็น กลไกในการทำให้เกิดทางเลือกที่ สุ่มค่าขึ้นมา ในที่นี้ เรามี คำสั่งหนึ่งชื่อว่า flipCoin ที่จะให้ค่าสุม เป็น True หรือ Fale โดยมีความน่าจะเป็นในการให้ค่าเท่าๆ กัน 50/50
ในบทความนี้ เราจะทำโปรแกรมต่อจากคราวที่แล้วและใส่ flipCoin เพื่อให้เราไม่ต้องหมุนขวาทางเดียว ถ้าจำตัวอย่างที่แล้วไม่ได้แนะนำให้ไปอ่านดูก่อนมาต่อที่นี่นะครัยโดยไปตาม link นี้ แล้วกลับมาต่อที่นี่กัน
ก็จะเพิ่มเติมจากเติมว่าหากตรวจแล้วพบว่าด้านหน้ามีผนัง เราจะสุมหัน ไม่ซ้ายก็ขวา เช็คไปเรื่อย ๆ จนกว่าจะพบว่าด้านหน้าเดินต่อได้จึงเดิน เราจึงเพิ่มเติมที่ code เราได้ว่า จากเดิม
repeat{
if(frontIsObstacle) { # ตรวจดูว่าด้านหน้าไปได้ไหมถ้ามี ให้หมุนขวา
right
}else { #ถ้าไม่มีก็ สั่งเดิน 1 ครั้ง
forward(1)
}
}
เมื่อเพิ่มเข้า ไปผมจะเขียนดังนี้
repeat{
if(frontIsObstacle) { # ตรวจดูว่าด้านหน้าไปได้ไหมถ้ามี ให้ สุ่ม
if(flipCoin){
right
}else{
left
}
}else { #ถ้าไม่มีก็ สั่งเดิน 1 ครั้ง
forward(1)
}
}
มาดูผลการเพิ่ม code เขาไปในโปรแกรม จะได้ดังนี้ครับ
ซึ่งเราก็จะเห็นว่า code ที่เพิ่มเขาไปนั้นทำให้ พฤติกรรมของ หุ่นเปลี่ยนไป มีความสามารถหาทางที่ไม่มีอะไรขวางกันอกกไปได้ แต่เป็นแบบไม่ฉลาดนัก เพราะเขาก็จะหมุ่นหนีทางตันไปเรื่อย ๆ หนีออกได้แต่ เป็นแบบสุ่ม
ถ้าหากเราต้องทำให้หุ่นเราฉลาดกว่านี้ พวกเราลองคิดเพิ่มเติมดูนะครับว่าจะทำอย่างไร เอาไว้ต่อบทหน้านะครับ
ต่อไป: ฝึกการเขียนโปรแกรม ด้วย Robo MIND ภาค #4 คำสั่งตรวจจับสิ่งรอบตัวหุ่นยนต์ / Sensing the environment
s.teerapong@gmail.com
ฝึกการเขียนโปรแกรม ด้วย Robo MIND ภาค #3
เป็นการเขียนเรื่องการโปรแกรมต่อเนื่องในรอบ 10 ปีเนื่องจากยังเห็นมียอดผู้เข้ามาดูในเรื่อง RoboMind อย่างต่อเนื่องมีเวลาก็อยากจะเขียนเพิ่ม เผื่อมีผู้ที่อ่านเพิ่มเติม ในส่วนนี้จะเป็นตัวอย่างการเขียนโปรแกรมในหัวข้อสั้น ๆ และตัวอย่างโปรแกรม
โจทย์ : ต้องการให้หุ่นยนต์ เดินไปข้างหน้าจากจุดเริ่มต้นเมื่อถึงผนังและเดินต่อไม่ได้ ให้ เลี้ยวซ้าย หรือขวาแล้วเดินต่อถ้าไปไม่ได้ให้ เลี้ยวซ้ายหรือขวา แล้วเดินวนซ้ำไปเรื่อย ๆ ไม่มีหยูด
สำหรับผม ก็จะเขียนง่ายๆ ด้วยโครงสร้าง Repeat ก่อน แล้วเดินหน้าไป หนึ่งเสต็ปก่อน แล้วจะทำซ้ำไปเรื่อย ๆ จะแบบนี้จะเห็นภาพก่อนว่า เมื่อหุ่นเดินหน้าไป ก็จะชนเข้ากับผนัง ตัวอย่าง Code เป็นแบบนี้
repeat {
forward (1)
}เมื่อสั่งทำงาน หรือ Run จะพบว่า เจ้าหุ่นเดินทางไปในทิศทางที่มัน หันไปอยู่ไปเรื่อยๆ จยจะพบผนังแล้วก็หยุดเพราะไปไม่ได้ เราจะต้อง ดังนั้นเรามีคำสัง frontIsObstacle เอาไว้ตรวจสอบว่าข้างหน้าเรามีอะไรขวางไหม แล้วเราจะหมุนหุ่นไป หนึ่งครั้งด้วยคำสั่ง right แล้ว วนซ้ำไปเรื่อย ๆ แบบนี้
repeat{
if(frontIsObstacle) { # ตรวจดูว่าด้านหน้าไปได้ไหมถ้ามี ให้หมุนขวา
right
}else { #ถ้าไม่มีก็ สั่งเดิน 1 ครั้ง
forward(1)
}
}ใน Video เป็นการ Run code ด้านบนนะครับ ลองดูการทำงาน หุ่นเราฉลาดขึ้นอีกนิส คือเมื่อเตินต่อไม่ได้ ก็หมุนขวาครั้งหนึ่ง แล้วก็ ตรวจสอบใหม่ ถ้าว่างก็เดินหน้า ไปเรื่อย ๆ แต่ถ้าเราดู Videoไปเรื่อย ๆ จะพบว่า เขาจะไปวนอยู่ที่หนึ่งไปต่อไปได้แล้ว ลองมาช่วยกันหาวิธีที่จะให้หุ่น เราหันซ้าย บ้าง หันขวาบ้าง จะได้ไม่เป็น pattern เดิม ลองทำกันดูนะครับ ครั้งหน้าจะมาเพิ่มเติม ข้อมูลคำสั่งเพิ่มเติม ที่ link
s.teerapong@gmail.com
การจัดการ Memory ของ Arduino [Arduino Memories]
Arduino มี Memory อยู่ 3 ชนิดคือ
- Flash หรือ Program Memory
- SRAM
- EEPROM
Flash Memory
ใช้สำหรับการบันทึก Program Image และข้อมูลตั้งต้นต่างๆ เราสามารถ run โปรแกรมจาก flash memory ได้แต่เราไม่สามารถแก้ไขข้อมูลใน flash memory จาก code ที่ทำงานอยู่ได้ หากต้องการแก้ไขข้อมูลเราจะต้องทำการสำเนาไปที่ SRAM
Flash memory นั้นใช้เทคโนโลยีเดียวกันกับ thumb-drive และ SD cards ซึ่งเป็นแบบ non-volatile หมายถึง program หรือข้อมูลจะคงอยู่แม้ว่าจะไม่มีไฟหล่อเลี้ยงอยู่ก็ตามหรือมีลักษณะเหมือน hard disk แต่มันก็มีข้อจำกัดในเรื่องจำนวนครั้งในการเขียนกล่าวคือเราจะเขียนหรือบันทึกข้อมูลลง flash memory ได้ประมาณ 100000 ครั้ง (100000 write cycle) มากพอที่จะใช้งานสัก 10 – 20 ปีแหละครับ ( สมมติว่าเราเขียนลงบน flash memory 10 ครั้งต่อวันเราก็จะใช้เวลาประมาณ 27 ปีครับ )
SRAM
หรือ Static Random Access Memory นั้นสามารถอ่านหรือเขียนได้จากโปรแกรม code ที่ทำงานอยู่ SRAM นั้นถูกใช้ในหลายๆจุดประสงค์คือ
- Static Data เป็นส่วนของ memory ที่กันไว้สำหรับ global variable และ static variable ของโปรแกรมสำหรับตัวแปรที่ถูกกำหนดค่าเริ่มต้นเมื่อเริ่ม start ระบบจะทำการสำเนาค่าเริ่มต้นนั้นจาก flash memory มาใส่ให้
- Heap เป็นส่วนที่เก็บข้อมูลแบบ dynamic หรือข้อมูลที่มีการ allocate ระหว่างที่โปรแกรมทำงาน ส่วนของ Heap นั้นจะขยายจากส่วนบนของ static data ขึ้นไปโดยใช้ส่วนของ memory ที่ว่างไปเรื่อยๆในระหว่างที่มีการจองและใช้งานของโปรแกรมที่ทำงานอยู่
- Stack เป็นส่วนของ memory ที่ใช้เก็บข้อมูลตัวแปรแบบ local และเก็บรายการ interrupts และ function call ต่างๆ memory ในส่วนของ stack จะขยายจากด้านบนสุดของ memory ลงมาหา Heap ดังนั้นทุกๆ ตัวแปร รายการ interrupts และ function call นั้นจะทำให้ memory ส่วน stack ขยายลงมากเรื่อยๆ การ return จาก interrupt หรือจาก function call นั้นจะคืนพื้นที่ว่างให้กับ SRAM
ปัญหาส่วนใหญ่ของ Memory เกิดจากการขยายขนนาดของ stack และ heap จนมาชนกันเมื่อเกิดการชนกันของ stack และ heap พื้นที่ข้อมูลของส่วนที่ถูกบันทึกทับก็จะเสียหายส่งผลให้เกิดการทำงานผิดพลาดแบบไม่สามารถคาดเดาผลการทำงานได้หรือในบางครั้งก็อาจทำให้เกิดการล่มของโปรแกรมไปเลย หรือในบางครั้งผลของการชนกันอาจไม่สังเกตเห็นได้จนกระทั่งเกิด error ขึ้นภายหลังจากนำเอาโปรแกรมไปใช้งานแล้วก็ได้
EEPROM
เป็น non-volatile memory อีกอันหนึ่งซึ่งสามารถอ่านและเขียนโดยโปรแกรม code ที่ทำงานอยู่แต่ข้อจำกัดของมันคือต้องอ่านทีละ byte ทำให้เวลาใช้งานยุงยากหน่อยและการอ่านก็ช้ากว่า SRAM นอกจากนี้ก็ยังมีข้อจำกัดในการเขียนที่ 100000 write cycle ( แต่การอ่านไม่จำกัด )
Arduino Memory Comparison
ตารางด้านล่างแสดงถึงข้อเปรียบเทียบของจำนวน memory แต่ละชนิดของแต่ละ model ของ Arduino และ Arduino compatible board
ครับ เรารู้รูปแบบของ Memory ต่าง ๆ กันคร่าวแล้ว ทำไงเราจะตรวจสอบว่า โปรแกรมที่เราเขียนนั้นใช้ Memory ไปเท่าไร หมายถึงอะไรเท่าไรนะครับ มีคำอธิบายต่อไปเรื่องการตรวจสอบ ใน ตอนต่อไปครับ เรื่อง การตรวจสอบการใช้ Memory ( Measuring Memory Usage )
ขอให้สนุกกับการ เรียนรู้นะครับ
ธีระพงษ์ สนธยามาลย์
Teerapong Sontayaman 's Kode Talker .NET 