No.373

ประพนธ์ อัศวภาณุวัฒน์

prapona@hotmail.com

 

 

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

 

Python

 

          ภาษา Python ผู้เขียนขออนุญาตเขียนภาษาไทยว่าไพธอนเป็นตัวแปรภาษาที่คิดค้นขึ้นโดยคุณ Guido Van Rossum ออกเวอร์ชั่น 0.9.0 ในปี 1991 เป็นเวอร์ชั่นแรกให้ใช้งาน ผู้เขียนขออนุญาตไม่กล่าวถึงประวัติความเป็นมาของภาษาไพธอน หากผู้อ่านท่านใดสนใจสามารถค้นหาได้จากอินเทอร์เน็ตครับ อย่างไรก็ตามท่านผู้อ่านจำเป็นต้องแวะไปเยี่ยมชมเว็บไซต์^[1] อย่างเป็นทางการของภาษา Python เพราะเป็นแหล่งรวบรวมโปรแกรม รวมถึงเอกสารให้ดาวน์โหลดมาใช้งาน และเว็บไซต์ Learn Python the hard way^[2] ซึ่งเป็นเว็บไซต์สอนการใช้งานภาษาไพธอนที่ผู้เริ่มต้นใช้งานต้องแวะเข้าไปเยี่ยมชมและเรียนรู้

                       

          ไพธอนเป็นตัวแปรภาษาชนิด Interpreter ซึ่งแตกต่างจากภาษา C/C++ ที่เป็นตัวแปรภาษาชนิดคอมไพเลอร์ (Compiler) กล่าวคือ รหัสต้นฉบับ (Source Code) ของภาษา C/C++ จะถูกเปลี่ยนเป็นรหัสภาษาเครื่องด้วยคอมไพเลอร์ก่อนป้อนให้หน่วยประมวลผลทำงาน แต่ Interpreter จะแปลงเป็นไบต์โค้ด (Byte Code) ก่อนส่งให้หน่วยประมวลผลทำงาน อย่างไรก็ตามไพธอนก็ไม่สามารถจัดอยู่ในกลุ่มเดียวกันกับตัวแปรภาษาแบบ Interpreter อื่นๆ เช่น ภาษาจาวา (Java) หรือภาษาซีชาร์ป (C#) เนื่องจากลักษณะการทำงานแตกต่างกัน โดยภาษาจาวาและซีชาร์ปจะแปลงเป็นไบต์โค้ดเพื่อให้หน่วยประมวลผลเสมือน (Virtual) ดำเนินการซึ่งสามารถนำไปรันได้ทุกแพลตฟอร์มที่สนับสนุน แต่ภาษาไพธอนเป็นตัวแปรภาษา Interpreter แบบตัวกลาง (Intermediate) กล่าวคือ ต้องมีตัวแปรภาษาเฉพาะสำหรับระบบปฏิบัติการนั้นๆ

                       

          ไพธอนมีจุดเด่นที่เป็นโปรแกรมเชิงวัตถุ (Object-oriented) ทั้งยังเป็นภาษา High Level ที่เข้าใจได้ง่าย ซึ่งผู้ใช้งานที่ไม่มีประสบการณ์เลยสามารถเริ่มต้นเรียนรู้เองได้โดยง่ายและอย่างรวดเร็ว

 

แรสพ์เบอร์รี่ ไพธอน

 

          ภาษาไพธอนถูกกำหนดเป็นภาษามาตรฐานสำหรับระบบคอมพิวเตอร์แรสพ์เบอร์รี่ พายน์ที่ใช้งานระบบปฏิบัติการแรสเบี้ยน โดยติดตั้งโปรแกรม Python IDLE (Integrated Development and Learning Environment) ทั้งไพธอนเวอร์ชั่น 2 และไพธอนเวอร์ชั่น 3 มาพร้อมกับระบบเรียบร้อย เราสามารถเรียกใช้งานโดยเรียกใช้จากเมนู (Menu) -> โปรแกรมมิ่ง (Programming) และเมนู Python 3 แสดงดังรูปที่ 1

 

 

รูปที่ 1 การเปิดโปรแกรม Python 3 เพื่อเขียนโปรแกรมภาษาไพธอน

 

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

                       

          เมื่อคลิกเลือกโปรแกรม Python 3 แล้ว โปรแกรมจะเปิดหน้าต่าง Python 3.4.2 และแสดงเคอร์เซอร์ Command-line Prompt รอให้ป้อนคำสั่งดังรูปที่ 2 ลักษณะการทำงานของโปรแกรมจะทำงานในโหมดโต้ตอบ (Interactive Mode) กล่าวคือ ผู้อ่านสามารถพิมพ์คำสั่งให้โปรแกรมไพธอนดำเนินการได้ทันที เช่น

 

 

รูปที่ 2 โปรแกรม Python 3 (IDLE)

 

          พิมพ์คำสั่ง print( “Micro Computer” ) ระบบจะแสดงข้อความ Micro Computer ที่หน้าจอคอนโซลทันที

                       

          หรือ ทดลองพิมพ์คำสั่ง print( “The result of 1+2 = “, 1+2 ) ระบบจะแสดงข้อความดังรูปที่ 3

 

 

รูปที่ 3 ทดลองพิมพ์คำสั่งภาษาไพธอน

 

          ผู้เขียนขอให้คลิกเลือกเมนู File -> New File เพื่อเปิดหน้าต่างใหม่ ทำการป้อนโปรแกรมแทนการพิมพ์คำสั่งแบบโต้ตอบดังแสดงในหน้าต่างขวาของรูปที่ 2 ครับ

                       

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

 

• คลิกเมนู Run -> Check Module โปรแกรมไพธอนจะทำการตรวจสอบโมดูลต่างๆ ว่าถูกต้องครบถ้วนหรือไม่
• คลิกเมนู Run -> Run Module โปรแกรมไพธอนจะทำการตีความและดำเนินการคำสั่งทีละคำสั่งจนครบทุกคำสั่งในโปรแกรม กรณีที่พบความผิดพลาดโปรแกรมจะหยุดทำงานที่ตำแหน่งนั้นและแจ้งความผิดพลาดให้ทราบ

 

          มาถึงจุดนี้ผู้เขียนขออนุมานว่าท่านผู้อ่านพอจะเข้าใจการใช้งานโปรแกรม Editor Python IDLE พอสมควรเพื่อให้เราพัฒนาการโปรแกรมด้วยภาษาไพธอนมากขึ้น ผู้เขียนขอเชิญท่านผู้อ่านลองศึกษาพัฒนาโปรแกรมร่วมกันกับเหตุการณ์สมมติดังต่อไปนี้ครับ

                       

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

                       

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

                       

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

 

รหัสมอร์ส

 

          รหัสมอร์สเป็นรหัสที่ใช้สัญลักษณ์จุดและขีดแทนตัวอักษร คิดค้นโดยคุณแซมมวล ฟินลี บรีซ มอร์ส (Samuel Finley Breese Morse) ในปี 1837 สำหรับกิจการโทรเลขในสมัยนั้น ความน่าสนใจของรหัสมอร์สอยู่ที่เป็นรหัสที่ใช้งานง่าย ไม่จำเป็นต้องใช้เครื่องมือที่มีวิทยาการสูงในการส่งข้อความตามสายไปยังที่ห่างไกล รูปที่ 4 แสดงตารางการเข้ารหัสมอร์สแบบสากลสำหรับตัวอักษร A-Z และชุดตัวเลข

 

 

รูปที่ 4 ตารางรหัสมอร์สรูปแบบสากล

 

          การเข้ารหัสมอร์สให้ความสำคัญกับคาบเวลา โดยหนึ่งจุด (Dot) แทนสัญญาณ 1 คาบเวลา (สัญญาณอาจจะเป็นเสียงหรือแสง) และขีด (Dash) แทนสัญญาณขนาด 3 คาบเวลา หรือเป็น 3 เท่าของจุด โดยมีเงื่อนไขประกอบดังนี้

 

1. ช่องว่างระหว่างตัวสัญลักษณ์ในตัวอักษรเดียวกันมีความกว้าง 1 คาบเวลา
2. ช่องว่างระหว่างตัวอักษรในคำเดียวกันมีความกว้าง 3 คาบเวลา
3. ช่องว่างระหว่างคำมีความกว้าง 7 คาบเวลา หรืออัตราส่วน 1 ต่อ 7 เมื่อเทียบกับคาบเวลาของจุด

 

          ตัวอย่างเช่น ตัวอักษร ‘A’ มีสัญลักษณ์รหัสมอร์ส คือ “.-” (Dot Dash) ถ้าส่งเป็นสัญญาณเสียงกำหนดให้ 1 ช่องคือ 1 คาบเวลา ซึ่งเป็นเวลาเท่ากับ 1 วินาที

 

 

รูป morsecode

 

          การถอดรหัสมอร์สเราสามารถดำเนินการตามตารางถอดรหัสมอร์สดังรูปที่ 5 โดยมีจุดเริ่มต้นที่ตำแหน่ง (Start) และเคลื่อนย้ายไปเส้นทางซ้ายหรือขวาตามชนิดสัญญาณที่ได้รับ เช่น ถ้าได้รับสัญญาณ ‘Dot’ ให้เคลื่อนที่ไปในเส้นทางจุดทางซ้าย และถ้าได้รับสัญญาณ ‘Dah’ ให้เคลื่อนที่ไปตามเส้นทางขีดทางขวา

 

 

รูปที่ 5 ตารางถอดรหัสมอร์ส

 

          ตัวอย่างเช่น ถ้าต้องการถอดรหัสสัญญาณ ‘Dah Dot Dah Dah’ ให้เริ่มต้นที่จุด (Start) ดังรูปที่ 6 เคลื่อนที่ไปตามสัญญาณ Dah แรก โดยเคลื่อนที่ไปทางขวา 1 ครั้ง (ถึงตัว T) และเคลื่อนที่ไปทางซ้ายตามเส้นทางของ Dot (ถึงตัว N) และเคลื่อนที่ไปทางขวาอีก 2 ครั้ง จนสิ้นสุดที่ตัวอักษร Y นั่นคือ สัญญาณนี้จะถอดรหัสได้เป็นอักษร ‘Y’

 

 

รูปที่ 6 แสดงการถอดรหัสตัวอักษร ‘Y’

 

โปรแกรมเข้ารหัสมอร์ส

 

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

 

• สัญลักษณ์ ‘.’ (Dot) แทนสัญญาณ Dot มีค่า 1 คาบเวลา
• สัญลักษณ์ ‘-’ (Dah) แทนสัญญาณ Dah มีค่า 3 คาบเวลา
• สัญลักษณ์ ‘+’ (Plus) แทนช่องว่าง (Silent Signal) ระหว่างตัวอักษร มีค่า 3 คาบเวลา
• สัญลักษณ์ ‘/’ (Slash) แทนช่องว่าง (Silent Signal) ระหว่างคำ มีค่า 7 คาบเวลา

                       

          โปรแกรม MorseCode.py แสดงดังลิสติงที่ 1 (ท้ายบทความ) ผู้เขียนพยายามเขียนส่วนของโปรแกรมให้อยู่ในรูปแบบโปรแกรมย่อย ประกอบด้วย 4 โปรแกรมย่อยคือ

 

1. โปรแกรมย่อย ConvertToMorseCode เป็นโปรแกรมย่อยที่ทำหน้าที่แปลงข้อความที่ป้อนให้เป็นสัญลักษณ์รหัสมอร์สตามนิยามที่กำหนดข้างต้น
2. โปรแกรมย่อย Init โปรแกรมย่อยที่กำหนดให้ใช้สำหรับกำหนดค่าเบื้องต้นของโปรแกรม กล่าวคือ คำสั่งที่บรรจุในโปรแกรมย่อย Int กำหนดให้ทำงานเพียงครั้งเดียวเพื่อกำหนดค่าเบื้องต้นสำหรับโปรแกรม
3. โปรแกรมย่อย Run เป็นส่วนของโปรแกรมย่อยที่บรรจุคำสั่งให้ประมวลผลตามจุดมุ่งหมายของโปรแกรม กล่าวคือ โปรแกรมย่อยนี้กำหนดให้ทำงานวนรอบจนสิ้นสุดการทำงานของโปรแกรม
4. โปรแกรมย่อย Main เป็นโปรแกรมหลักที่เรียกใช้โปรแกรมย่อย Init เพื่อกำหนดค่าเบื้องต้นและเรียกใช้โปรแกรมย่อย Run เพื่อประมวลผลงานตามแต่จุดประสงค์ของโปรแกรม

                       

          สำหรับตัวแปรเก็บข้อมูลรหัสมอร์สผู้เขียนกำหนดตัวแปรเก็บข้อมูลรหัสมอร์สด้วยตัวแปรชนิดดิกชั่นนารี (Dictionary) โดยใช้ตัวแปรชื่อ morseCodeDict โดยมีรูปแบบของดิกชั่นนารีคือคีย์ : ข้อมูล (Key : Value) ซึ่งผู้เขียนใช้ตัวอักษร ‘A’ ถึง ‘Z’ เป็นคีย์ และเก็บข้อมูลเป็นสัญลักษณ์รหัสมอร์ส (ทุกชุดข้อมูลจะคั่นด้วยเครื่องหมาย , (จุลภาคหรือ Comma) ดังนี้

 

          morseCodeDict ={
       "A" : ".-",
       "B" : "-...",
       "C" : "-.-.",
...
       "Z" : "--..",
       " " : "/" }

 

          นั่นคือ ถ้าใช้คำสั่ง print( morseCodeDict[ “A”] ) จะได้ผลลัพธ์เป็น .-

                       

          ผู้เขียนได้กำหนดตัวแปรแบบโกลบอล (Global) ซึ่งมีคุณสมบัติคือสามารถมองเห็นได้ทุกส่วนในโปรแกรม ดังนี้

 

          running = 0             : ใช้เป็นตัวแปรกำหนดเงื่อนไขการรันโปรแกรมหลัก โดยค่า 1 คือรันไม่หยุด
dot = 1                   : ใช้กำหนดค่าของ Dot มีค่า 1 คาบเวลา (ยังไม่ใช้งานในโปรแกรมนี้)
dah = 3                   : ใช้กำหนดค่าของ Dah มีค่า 3 คาบเวลา (ยังไม่ใช้งานในโปรแกรมนี้)
spcBtCh = 3            : ใช้กำหนดค่าช่องว่างแยกตัวอักษร (Silent Signal) มีค่า 3 คาบเวลา (ยังไม่ใช้งานในโปรแกรมนี้)
speBtWord = 7        : ใช้กำหนดค่าช่องว่างแยกคำ (Silent Signal) มีค่า 7 คาบเวลา (ยังไม่ใช้งานในโปรแกรมนี้)
inputStr = ""           : ตัวแปรสำหรับรับตัวอักษรจากแป้นคีย์บอร์ด
morseCodeStr = ""  : ตัวแปรสำหรับเก็บรหัสมอร์สจากการแปลงค่า

 

          สำหรับโปรแกรมย่อยมีส่วนของโปรแกรมที่สำคัญดังต่อไปนี้

 

          โปรแกรมย่อย ConvertToMorseCode

 

          เป็นโปรแกรมย่อยสำหรับเปลี่ยนข้อความที่บรรจุอยู่ในตัวแปร Content ให้เป็นสายอักขระรหัสมอร์ส แล้วให้ค่าคืนกลับออกไป การสร้างโปรแกรมย่อยบนภาษาไพธอนจะใช้คำเฉพาะ (Reserve Word) คือ def นำหน้าชื่อโปรแกรมย่อยที่ตำแหน่งต้นบรรทัด มีรูปแบบดังรูปที่ 7 ดังนี้

 

 

รูปที่ 7 รูปแบบของโปรแกรมย่อย

 

1. ขึ้นต้นด้วยคำเฉพาะ def ตามด้วยชื่อโปรแกรมย่อย ถ้ามีพารามิเตอร์ (Parameter) หรือค่าใดๆ ที่ต้องส่งให้โปรแกรมย่อยให้กำหนดไว้ในวงเล็บและสิ้นสุดด้วยเครื่องหมายโคลอน “:” (Colon)
2. ย่อหน้าเพื่อกำหนดขอบเขตของโปรแกรมย่อย กล่าวคือ ทุกบรรทัดที่อยู่ภายใต้ย่อหน้าของคำเฉพาะ def จะถือเป็นส่วนหนึ่งของโปรแกรมย่อยทั้งหมด
3. กำหนดส่วนของโปรแกรมไว้ในส่วน ซึ่งอยู่ภายใต้ย่อหน้าของคำเฉพาะ def
4. ชุดคำสั่งใดๆ ที่อยู่หลังคำสั่งที่จบด้วยเครื่องหมายวรรคตอนโคลอน “:” จะต้องย่อหน้าเพื่อให้อยู่ในขอบเขตของคำสั่งข้างต้น เช่น คำสั่ง for loop ตามตัวอย่าง เป็นต้น
5. ถ้าต้องการคืนค่ากลับออกจากโปรแกรมย่อย ให้ใช้คำเฉพาะ return ตามด้วยตัวแปรหรือค่าที่ต้องการส่งคืนออกไป

   

          ความหมายของส่วนของโปรแกรมย่อย ConvertToMorseCode

 

          # กำหนดโปรแกรมย่อยชื่อ COnvertToMorseCode
def ConvertToMorseCode( content ): # มีส่วนของโปรแกรมย่อยดังนี้
encodeStr = "" # กำหนดค่า encodeStr เป็น 0 (ศูนย์)
for ch in content : # วนรอบอ่านค่าตัวอักษรทั้งหมดใน Content โดยบรรจุในตัวแปร ch ครั้งละ 1 ตัวอักษร
# กำหนดให้ encodeStr เพิ่มค่าจากดิกชั่นนารี morseCodeDict โดยใช้อินเด็กซ์เป็นอักษรใหญ่ (ch.upper)
encodeStr = encodeStr + morseCodeDict[ ch.upper() ]
# เพิ่ม ‘+’ ต่อท้ายทุกตัวอักษรเพื่อแยกคำ
encodeStr = encodeStr + "+"
return( encodeStr ) # ให้ค่า encodeStr กลับออกจากโปรแกรมย่อย

 

          โปรแกรมย่อย Init()

 

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

 

          global running # กำหนดให้ตัวแปร Running สามารถเปลี่ยนแปลงค่าได้ในโปรแกรมย่อย
running = 1 # กำหนดค่าเป็น 1
print( "Morsecode application" )

 

          โปรแกรมย่อย Run

 

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

 

          def Run():
          while running == 1: # วนรอบจนว่า running จะไม่เท่ากับ 0 (ศูนย์)
               # รับข้อมูลด้วยโปรแกรมย่อย inputStr
               inputStr = input( "Please enter string to convert to morsecode : " )
               # แปลงข้อมูลเป็นการเข้ารหัสข้อมูล
               morseCodeStr = ConvertToMorseCode( inputStr )
               print( "\n" )
               print( "Input str = ", inputStr, "\n" )
               print( "morseCode = ", morseCodeStr, "\n" )
               print( "\n" )

 

          หลังจากรันโปรแกรม MorseCode.py โปรแกรมจะให้ใส่ข้อมูลที่ต้องการเข้ารหัสมอร์ส เมื่อใส่ข้อมูลและกดปุ่ม [Enter] แล้ว โปรแกรมจะให้ค่าออกมาเป็นสายอักษขระรหัสมอร์ส ผู้เขียนคิดว่าท่านผู้อ่านสามารถทำความเข้าใจรหัสมอร์สดังกล่าวได้ด้วยตนเองไม่มากก็น้อยครับ

 

เก็บตกจากฉบับที่แล้ว

 

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

                       

          กรณีดังกล่าวนี้เราอาจจะมีความต้องการใช้งานหน้าจอ Remote Desktop ที่มีขนาดเพียง 800x600 หรือ 1024x768 ก็เพียงพอต่อการใช้งาน ซึ่งเราสามารถปรับขนาดหน้าจอเดสก์ท้อปของระบบคอมพิวเตอร์แรสพ์เบอร์รี่ พายน์ได้โดยแก้ไขไฟล์ /boot/config.txt ดังนี้

 

1. เปิดหน้าต่างเทอร์มินัล (Terminal) เพื่อเข้าสู่หน้าจอ Command Line
2. พิมพ์คำสั่ง sudo pcmandfm เพื่อเปิดโปรแกรม File Manager
3. เข้าไปที่โฟลเดอร์ /boot เปิดไฟล์ config.txt ด้วยโปรแกรม Leafpad โดยคลิกเมาส์ปุ่มขวาที่ไฟล์ config.txt แล้วเลือกโปรแกรม Leafpad
4. แก้ไขพารามิเตอร์ในไฟล์ config.txt ดังนี้

 

          hdmi_force_hotplug=1
hdmi_ignore_edid=0xa5000080
hdmi_group=2
hdmi_mode=16

 

          โดย hdmi_mode สำหรับ group 2 สามารถเปลี่ยนพารามิเตอร์สำหรับความละเอียดหน้าจอแสดงผลตามรายการความละเอียดหน้าจอที่ระบบคอมพิวเตอร์แรสพ์เบอร์รี่ พายน์สนับสนุน ตามลิสต์รายการในข้อกำหนด RPiconfig^[3] โดยขนาดจอมาตรฐานที่ผู้เขียนกล่าวถึงมีดังต่อไปนี้

 

          hdmi_mode=4 640x480 60 Hz
hdmi_mode=9 800x600 60 Hz
hdmi_mode=16 1024x768 60 Hz
hdmi_mode=28 1280x800 60 Hz

 

          5. เมื่อแก้ไขเรียบร้อยให้ทำการบันทึกและรีสตาร์ทระบบใหม่อีกครั้ง หน้าจอจะปรับเปลี่ยนความละเอียดในการแสดงผลเป็นขนาดใหม่ตามที่กำหนด

 

ส่งท้าย

 

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

                       

          สำหรับฉบับนี้ผู้เขียนต้องขอจบบทความแต่เพียงเท่านี้ ฉบับหน้าพบกันใหม่ สวัสดีครับ

 

อ้างอิง
1. Python Web Site : Available from https://www.python.org/
2. Learn Python the hard way : Available from http://learnpythonthehardway.org/
3. Rpiconfig : Available from http://elinux.org/RPiconfig

 

ลิสติงที่ 1 ส่วนของโปรแกรม MorseCode.py

 

          #---------------------------------------------------------------------
#
# Morse Code Encoder
#
#
#---------------------------------------------------------------------
# -*- coding: utf-8 -*-

morseCodeDict ={
     "A" : ".-",
     "B" : "-...",
     "C" : "-.-.",
     "D" : "-..",
     "E" : ".",
     "F" : "..-.",
     "G" : "--.",
     "H" : "....",
     "I" : "..",
     "J" : ".---",
     "K" : "-.-",
     "L" : ".-..",
     "M" : "--",
     "N" : "-.",
     "O" : "---",
     "P" : ".--.",
     "Q" : "--.-",
     "R" : ".-.",
     "S" : "...",
     "T" : "-",
     "U" : "..-",
     "V" : "...-",
     "W" : ".--",
     "X" : "-..-",
     "Y" : "-.--",
     "Z" : "--..",
     " " : "/" }

#---------------------------------------------------------------------

running = 0                  # running flag
dot = 1                        # dot size
dah = 3                       # dah size
spcBtCh = 3                # space between character size, '+' sign
speBtWord = 7            # space between word size, '/' sign
inputStr = ""               # text input
morseCodeStr = ""      # morseCode string

#---------------------------------------------------------------------

def ConvertToMorseCode( content ):
     encodeStr = ""
     for ch in content :
          encodeStr = encodeStr + morseCodeDict[ ch.upper() ]
          encodeStr = encodeStr + "+"
     return( encodeStr )

#---------------------------------------------------------------------

def Init():
     global running
     running = 1
     print( "Morsecode application" )

def Run():
     while running == 1:
          inputStr = input( "Please enter string to convert to morsecode : " )
          morseCodeStr = ConvertToMorseCode( inputStr )
          print( "\n" )
          print( "Input str = ", inputStr, "\n" )
          print( "morseCode = ", morseCodeStr, "\n" )
          print( "\n" )

#---------------------------------------------------------------------

def main():
     Init()
     Run()

#---------------------------------------------------------------------
# run the main function only if this module is executed as the main script
# means if you import this file as a module, will did not execute main program

if __name__=="__main__":
     # call the main function
     main()