Numerical Literacy
Numerical Literacy
จัดทำโดย
1.นางสาวมยุรี อรรคบุตร รหัส 503050361-4
2.นางสาวมัทนา เอกวงศ์ษา รหัส 503050362-2
3.นางสาววารินทร์ อันทอง รหัส 503050366-4
4.นางสาววัชราภรณ์ ชาวงษ์ รหัส 503050364-8
5.นางสาววิลาสิณีย์ มากนาคา รหัส 503050367-2
6.นายศานติรักษ์ อุณาพรหม รหัส 503050369-8
7.นางสาวอริษา พันธ์เทศ รหัส 503050377-9
8.นาสาวอรุณนี โทเท รหัส 503050387-7
เสนอ
อาจารย์อิสรา ก้านจักร
เอกสารฉบับนี้เป็นส่วนหนึ่งของรายวิชา การพัฒนาทักษะด้านการใช้เทคโนโลยีสารสนเทศ
ภาคเรียนที่ 1 ปีการศึกษา 2551
คำนำ
เนื่องจากในปัจจุบันเทคโนโลยีสารสนเทศได้พัฒนาไปอย่างรวดเร็วมากซึ่งผู้ใช้ก็ต้องอาศัยการเรียนรู้สิ่งต่างๆที่เกี่ยวข้องกับเทคโนโลยีสารสนเทศ ซึ่งในที่นี้เทคโนโลยีแบ่งได้หลายประเภท ดังนั้นสมาชิกในกลุ่มได้เล็งเห็นถึงความสำคัญจึงได้ทำการศึกษาเทคโนโลยีสารสนเทศ Numerical Literacy จึงได้ค้นหาข้อมูลแล้วนำมาคัดกรองเพื่อเก็บไว้เป็นเอกสารไว้ศึกษาให้สำหรับผู้ที่สนใจ หรือผู้ที่ต้องการศึกษาสามารถนำไปใช้ให้เกิดความรู้ได้ ซึ่งคณะผู้จัดทำหวังเป็นอย่างยิ่งว่าเอกสารฉบับนี้จะเป็นประโยชน์ต่อผู้ที่ต้องการศึกษา หากผิดพลาดประการใดก็ขอ อภัยไว้ ณ ที่นี้ด้วย
คณะผู้จัดทำ
สารบัญ
หน้า
ความหมาย Numerical Literacy 1
ความหมายของ CNC (Computer Numerical Control) 2
ข้อดี/ข้อเสีย 9
Numerical Programming 11
ตัวอย่างของการทำงานของเครื่องปริ้นเตอร์ 30
Numerical Literacy
Numerical คือ ตัวเลข 0 ถึง 9 ตัวอักษร หรือโค้ด เช่น A , B , C ถึง Z และสัญลักษณ์อื่น ๆ เช่น เครื่องหมาย + , - และ %
Numerical Literacy จึงหมายถึง การรู้ทางตัวเลข ซึ่งเป็นวิชาเกี่ยวกับตรรก เป็นตัวเลขที่ใช้เกี่ยวกับการควบคุมเครื่องจักรกลต่างๆ ซึ่งเป็นรายละเอียดเกี่ยวกับ CNC (Computer Numerical Control)
C ย่อมาจาก Control ( คอนโทรล ) หมายถึง การควบคุมโดยกำหนดค่า หรือตำแหน่งจริงที่ต้องการเพื่อให้เครื่องจักรทำงานให้ได้ค่าตามที่กำหนด
เอ็นซี ( NC ) หมายถึง การควบคุมเครื่องจักรกลด้วยระบบตัวเลขและตัวอักษร ซึ่งคำจำกัดความนี้ได้จากประเทศสหรัฐอเมริกา กล่าวคือ การเคลื่อนที่ต่าง ๆ ตลอดจนการทำงานอื่น ๆ ของเครื่องจักรกล จะถูกควบคุมโดยรหัสคำสั่งที่ประกอบด้วยตัวเลข ตัวอักษร และสัญลักษณ์อื่น ๆ ซึ่งจะถูกแปลงเป็นเคลื่อนสัญญาณ ( Pulse ) ของกระแสไฟฟ้าหรือสัญญาณออกอื่น ๆ ที่จะไปกระตุ้นมอเตอร์หรืออุปกรณ์อื่น ๆ เพื่อทำให้เครื่องจักรกลทำงานตามขั้นตอนที่ต้องการ
ความหมายของ CNC (Computer Numerical Control)
Computer ย่อมาจาก คอมพิวเตอร์ที่ติดตั้งบนเครื่องจักร
Numerical คือ ตัวเลข 0 ถึง 9 ตัวอักษร หรือโค้ด เช่น A , B , C ถึง Z และสัญลักษณ์อื่น ๆ เช่น เครื่องหมาย + , - และ %
C ย่อมาจาก Control ( คอนโทรล ) หมายถึง การควบคุมโดยกำหนดค่า หรือตำแหน่งจริงที่ต้องการเพื่อให้เครื่องจักรทำงานให้ได้ค่าตามที่กำหนด
ดังนั้น ซี เอ็น ซี ( CNC ) ซึ่งย่อมาจาก Computer Numerical Control คือ คอมพิวเตอร์หรือไมโครโปรเซสเซอร์ สำหรับใช้ควบคุมการทำงาน โดยมากจะเป็นงานโลหะที่มีความซับซ้อนและต้องการความแม่นยำสูง โดยที่การหล่อไม่สามารถทำได้หรือสามารถทำได้ก็ตาม
เครื่องจักรกลเอ็นซีในปัจจุบันนั้นส่วนมากจะหมายถึง เครื่องจักรกล ซีเอ็นซี ซึ่งจะมีคอมพิวเตอร์ที่สามารถเข้าใจตัวเลขและตัวอักษรหรือโปรแกรมที่ป้อนและขณะเดียวกัน จะใช้คอมพิวเตอร์สำหรับการควบคุมเครื่องจักรจากคำสั่ง หรือ โค้ดในโปรแกรมที่ป้อนเข้าไป โดยโปรแกรมดังกล่าวสามารถป้อนเข้าคอมพิวเตอร์โดยใช้
1. คีย์บอร์ด ( Keyboard ) หรือ แป้นพิมพ์
2. สื่อบันทึกความจำ เช่น แผ่นดิสก์ , แถบเทปแม่เหล็ก และ แถบเทปกระดาษ
3. ระบบสื่อสารเชื่อมโยงข้อมูล เช่น สายส่งสัญญาณ RS 232
เครื่องจักรกลพื้นฐานเช่น เครื่องกลึง เครื่องกัด เครื่องเจียรนัย และเครื่องตัดโลหะแผ่นเป็นเครื่องจักรกลที่มีความสำคัญอย่างยิ่งต่ออุตสาหกรรมการผลิตชิ้นส่วนเครื่องจักร เครื่องยนต์ และแม่พิมพ์ ตลอดจนหน่วยงานสร้าง – ซ่อมงานโลหะโดยทั่วไป และอาจกล่าวได้ว่าความก้าวหน้าของเครื่องจักรกลประสิทธิภาพสูงหลายประเภทในยุคปัจจุบันล้วนแต่มีรากฐานมาจากเครื่องจักรพื้นฐานเหล่านี้ทั้งสิ้น
รูปที่ 1 การทำงานของเครื่องกลึงที่ใช้มือคนในการหมุนเกลียวขับเพื่อป้อนมีดกลึงเข้าหาชิ้นงาน
ระบบ CNC (Computer Numerical Control) เป็นระบบคอมพิวเตอร์ที่ถูกสร้างขึ้นโดยมีวัตถุประสงค์หลักคือ เพื่อเปลี่ยนแปลงและควบคุมสภาพการทำงานของเครื่องจักรกลพื้นฐานดังกล่าวจากเดิมซึ่งใช้แรงงานคนในการทำงานร่วมกับเครื่องจักร ให้เครื่องจักรเหล่านี้สามารถทำงานได้โดยอัตโนมัติด้วยตัวเอง นอกจากนี้ ระบบ CNC ยังช่วยเพิ่มความสามารถให้เครื่องจักรพื้นฐานเหล่านี้สามารถทำงานลักษณะซับซ้อนได้ด้วยความรวดเร็วและแม่นยำในระดับที่พ้นความสามารถในการรับรู้ของมนุษย์โดยทั่วไปหลายสิบเท่าตัว สำหรับการประยุกต์ใช้ระบบ CNC ในเครื่องจักรพื้นฐานดังกล่าว ระบบ CNC จะประกอบไปด้วยมอเตอร์ไฟฟ้าจำนวนหนึ่งซึ่งถูกนำไปใช้ในการหมุนเกลียวขับแทนมือคน และระบบคอมพิวเตอร์ซึ่งใช้ในการควบคุมมุมและความเร็วที่มอเตอร์ไฟฟ้าเหล่านั้นหมุนเกลียวขับ โดยระบบคอมพิวเตอร์ดังกล่าวสามารถควบคุมมุมของมอเตอร์ได้ด้วยความละเอียดถึง 0.1 องศาหรือดีกว่า หรือสามารถให้ความละเอียดในการป้อนอุปกรณ์ตัดเข้าสู่ชิ้นงานสูงถึง 0.02 มม หรือดีกว่า ทั้งนี้ขึ้นอยู่กับระยะคลอนของเกลียวขับ ตัวอย่างของการใช้งานระบบ CNC กับเครื่องกลึงในการป้อนมีดกลึงโดยใช้มอเตอร์ไฟฟ้า 2 ตัวแสดงไว้ในรูปที่ 2
รูปที่ 2 ระบบ CNC ใช้มอเตอร์ไฟฟ้าในการหมุนเกลียวขับเพื่อป้อนอุปกรณ์ตัดและใช้ระบบคอมพิวเตอร์ในการควบคุมมุมและความเร็วในการหมุนของมอเตอร์
ในปัจจุบัน มีการใช้ระบบ CNC สำหรับเครื่องจักรพื้นฐานในอุตสาหกรรมผลิตชิ้นส่วนเครื่องจักรกล เครื่องยนต์ แม่พิมพ์ และในหน่วยงานสร้าง – ซ่อมอย่างแพร่หลาย หากประมาณคร่าวๆ มูลค่าเบื้องต้นของระบบ CNC ในอุตสาหกรรมเหล่านี้อยู่ในระดับหลายพันล้านบาท ในทางปฏิบัติระบบ CNC ดังกล่าวและผู้เชี่ยวชาญในระบบดังกล่าวถูกนำเข้าจากประเทศที่พัฒนาแล้ว เช่น สหรัฐอเมริกา เยอรมัน และ ญี่ปุ่น เป็นต้น ทั้งนี้เนื่องจาก CNC ดังกล่าวเป็นเทคโนโลยีระดับสูงที่ยากต่อการออกแบบและการทำความเข้าใจจนสามารถนำมาใช้งานได้จริง อย่างไรก็ตาม ดร.พินิจ งามสม ได้ใช้เวลากว่า 4 ปีในการวิจัย ออกแบบ และพัฒนา จนประสบผลสำเร็จในการสร้างระบบ CNC ที่ใช้งานได้จริง โดยงานวิจัยที่เป็นรากฐานของผลงานนี้ได้รับการพิจารณาให้เป็นบทความดีเด่นสาขา Dynamics, Systems, and Control ในการประชุมเครือข่ายวิศวกรรมเครื่องกลแห่งประเทศไทย ในปี พ.ศ. 2545 และได้รับการตีพิมพ์ในวารสารวิชาการระดับสากลที่มีความแข็งแกร่งทางวิชาการมากที่สุดเล่มหนึ่ง คือ Journal of Dynamic System, Measurement, and Control โดย American Society of Mechanical Engineers ในปี พ.ศ. 2546
ระบบ CNC ที่สร้างขึ้นนี้สามารถควบคุมมุม ความเร็ว และแรงบิดในการหมุนของมอเตอร์ไฟฟ้าภายใต้ความไม่แน่นอนของภาระงานและคุณสมบัติภายในได้ 4 ตัวพร้อมกัน (ขยายได้เป็น 8 ตัวเพื่อการควบคุมแขนกลลักษณะต่างๆ) โดยใช้มาตรฐานรหัส G และ M ในการสั่งการ ระบบสามารถแสดงความก้าวหน้าของการทำงานได้ทั้งในเชิงต้วเลขและเชิงรูปภาพบนจอคอมพิวเตอร์ นอกจากนี้ยังสามารถเปลี่ยนพารามิเตอร์ของระบบควบคุมให้เข้ากับการใช้งานควบคุมเครื่องจักรได้หลากหลายรูปแบบ เช่น เครื่องกัด, เครื่องกลึง, แขนกล, เครื่องตัดพลาสม่า, เครื่องลอกพื้นผิว, และเครื่องพับโลหะ เป็นต้น ในการทดสอบ ระบบ CNC ที่สร้างขึ้น ถูกนำไปใช้ในการควบคุมเครื่องกัดที่ทำงานในสามมิติโดยใช้มอเตอร์ไฟฟ้ากระแสตรงจำนวน 4 ตัว ซึ่งในจำนวนนี้ มอเตอร์ 3 ตัวถูกใช้ไปในการป้อนชิ้นงานและดอกกัดในแนว X, Y, และ Z ส่วนมอเตอร์อีกหนึ่งตัวใช้ในการหมุนดอกกัดชิ้นงาน ระบบ CNC ที่ออกแบบและสร้างขึ้นนี้สามารถควบคุมให้เครื่องกัดทำงานได้โดยอัตโนมัติตามโปรแกรมที่ตั้งไว้ ด้วยความละเอียด 0.02 มม (ถูกจำกัดด้วยระยะคลอนของเกลียวขับที่ใช้อยู่) หลังจากการพัฒนาระบบ CNC ต้นแบบเสร็จสิ้นลง ในปัจจุบันระบบ CNC ดังกล่าวมีต้นทุนในการสร้างประมาณ 60,000 บาทต่อเครื่อง (รูปที่ 3 แสดงวงจรควบคุมของระบบ CNC, รูปที่ 4 แสดงโปรแกรมควบคุมที่ทำงานบนคอมพิวเตอร์, และรูปที่ 5 แสดงตัวอย่างชิ้นงานที่ได้จากเครื่องกัดที่ควบคุมการทำงานโดยระบบ CNC ที่ออกแบบและสร้างขึ้น)
ระบบ CNC นี้กำลังถูกเผยแพร่ออกสู่ภาคอุตสาหกรรมและภาคการศึกษาเพื่อการใช้งานจริงในหลายรูปแบบ ต้นแบบของระบบ CNC ที่ใช้ควบคุมการทำงานของเครื่องกัดและเครื่องกลึงถูกใช้เป็นอุปกรณ์การเรียนการสอนในห้องทดลองระบบควบคุมสังกัดภาควิชาวิศวกรรมเครื่องกล
รูปที่ 3 ส่วนหนึ่งของวงจรควบคุมระบบ CNC ที่ออกแบบและสร้างขึ้น
รูปที่ 4 ระบบ CNC แสดงผลการทำงานและความก้าวหน้าบนคอมพิวเตอร์
รูปที่ 5 ตัวอย่างชิ้นงานที่ได้จากเครื่องกัดที่ควบคุมด้วยระบบ CNC ที่สร้างขึ้น (Compressed250%)
ข้อดี
1. มีความเที่ยงตรงสูงในการปฏิบัติงานเพราะชิ้นงานต่าง ๆ ต้องการขนาดที่แน่นอน
2. คุณภาพสม่ำเสมอทุกชิ้นงานเท่ากันหมดเนื่องจากผลิตโดยใช้โปรแกรมในการสั่งเครื่องจักร CNC ทำงาน
3. โอกาสเกิดความเสียหาย หรือต้องแก้ไขชิ้นงานน้อยหรือแทบไม่มี เพราะชิ้นงานที่ทำจะใช้โปรแกรมในการควบคุมถ้าผิดพลาดก็แก้ไขที่โปรแกรม
4. สามารถทำงานได้ตลอด 24 ชั่วโมงโดยไม่ต้องหยุดพักเครื่องแต่ต้องมีคนควบคุมประจำเครื่อง CNC
5. มีความรวดเร็วสูงในการผลิตทำให้ได้ผลผลิตสูง เพราะสามารถกำหนดระยะเวลาในการผลิตชิ้นงานได้ว่าใช้เวลาในการทำงานกี่ชิ้นต่อวินาที / นาที / ชั่วโมง
6.สามารถคาดคะแนและวางแผนการผลิตได้อย่างแม่นยำ เพราะรู้ระยะเวลาในการ
ปฏิบัติงานเพื่อที่จะนัดหรือส่งงานลูกค้าได้ตรงตามเวลา
7. สามารถสลับเปลี่ยนรูปแบบของชิ้นงานได้หลากหลายรูปทรงเนื่องจากสะดวกและรวดเร็วในการทำงานเพราะใช้โปรมแกรมในการสั่งงาน
8. เมื่อเปรียบเทียบจำนวนผลผลิตที่เท่ากัน เครื่องจักรกล ซีเอ็นซี ใช้พื้นที่น้อยกว่าและลดพื้นที่การจัดเก็บชิ้นงาน
10. มีความสะดวก สำหรับใช้ในการผลิตชิ้นงานต้นแบบที่มีการแก้ไขบ่อย ๆ เพราะเวลาแก้ไขสามารถแก้ไขได้ที่โปรแกรม
11. ชิ้นงานที่มีความซับซ้อนสูงและมีหลายขั้นตอนการผลิต สามารถใช้เครื่องจักรกล
ซีเอ็นซี เครื่องเดียว ทำให้ไม่ต้องย้ายไปทำงานที่เครื่องอื่นให้เสียเวลาในการปฏิบัติงาน
12. ลดขั้นตอนในการตรวจสอบคุณภาพลงเพราชิ้นงานนั้นได้ขนาดเท่ากันทุก ๆ ชิ้นแต่ควรเลือกค่าของความเร็วรอบ , ความเร็วตัด ให้เหมาะสมเพื่อลดอายุการสึกหรอของทูลที่ใช้
13. ทำให้สามารถใช้ ทูล หรือ เครื่องมือตัดได้อย่างมีประสิทธิภาพ เพราะจะต้องคำนวณค่าต่าง ๆ มาก่อนลงมือปฏิบัติงานกับเครื่องจักร CNC
14. ลดแรงงานในสายการผลิตลงเนื่องจาก ผู้ควบคุมเครื่อง 1 คน สามารถคุมได้ 3 ถึง
5 เครื่อง
15. ใช้อุปกรณ์เสริมน้อย ไม่ต้องใช้แผ่นลอกแบบ ( Camplates หรือ Templates ) แต่ผู้ใช้จะต้องเขียนโปรแกรมให้ถูกต้อง
ข้อเสีย
1. มีราคาแพงมากเพราะต้องนำเข้าจากต่างประเทศเนื่องจากยังไม่มีการผลิตเครื่องจักร CNC ภายในประเทศ
2. ค่าซ่อมแซมสูง การซ่อมแซมมีความซับซ้อน เพราะทั้ง ฮาร์ดแวร์ และ ซอฟต์แวร์ รวมถึง คอมพิวเตอร์และอุปกรณ์ไฟฟ้า อิเล็คโทรนิกส์ ต้องใช้ผู้ชำนาญการ
3. อุปกรณ์และซอฟต์แวร์เสริม ( Option ) มีราคาสูงและต้องได้มาจากผู้ผลิตเครื่องจักร CNC นั้น ๆ เท่านั้น
4. ต้องมีความรู้พื้นฐานทางวิชาคณิตศาสตร์มากพอสมควรสำหรับใช้ในการเขียนโปรแกรมเพราะไม่นั้นไม่สามารถคำนวณหาค่าของจุดต่าง ๆ ได้เลย
5. ต้องมีพื้นที่ในการทำงานว่างพอและยังรวมไปถึงสิ่งอำนวยความสะดวกต่าง ๆ ให้แก่ผู้เขียนโปรแกรม NC
6. ต้องหางานป้อนให้เครื่องทำงานประจำอย่างสม่ำเสมอไม่ให้หยุดนิ่งเพราะอาจจะทำให้ชิ้นส่วนบางอย่างเสื่อมสภาพและเครื่องจักรจะได้รันเครื่องเตรียมพร้อมตลอดเวลา
7. ไม่เหมาะสมกับการผลิตชิ้นงานจำนวนน้อย ๆ ควรใช้กับผลิตชิ้นงานจำนวนมาก ๆ เพราะจะไม่ต้องเสียค่าใช้สูงในจ้างพนักงาน
8. ค่าซ่อมบำรุงรักษาเครื่องจักรสูงมาก ๆ เพราะต้องใช้ช่างผู้ชำนาญเฉพาะทางในการซ่อมแซม
9. ชิ้นส่วนอะไหล่ถ้าเกิดการชำรุดหรือเสียหายในบางกรณี ต้องรอส่งมาจากต่างประเทศอย่างเดียวเนื่องจากไม่ได้ผลิตในประเทศ
10. คอนโทรลเลอร์ เป็นภาษาอังกฤษ ช่างต้องเรียนรู้และมีการฝึกอบรมการใช้เครื่องและการเขียนโปรแกรมก่อนเริ่มใช้เครื่องเพราะไม่นั้นจะใช้ไม่เป็น
Numerical Programming
เขียนโปรแกรม bow_der_kleine
Numerical Arithmetic Programming คือ การเขียนโปรแกรมที่เน้นการคำนวน โดยใช้ Array และ Matrix เป็นหลัก การเรียกใช้ Operation หรือ Function ต่าง ๆ ไม่จำเป็นต้องเข้าถึงสมาชิกแต่ละตัวใน Array หรือ Matrix แต่สามารถเรียกใช้ผ่านตัวแปรที่เป็น Array หรือ Matrix ได้เลย เช่น ตัวอย่างแรก เป็นการใช้ Procecure Arithmetic ที่การบวก ต้องเข้าถึงสมาชิกทุกตัวใน List
a = [1,2,3,4,5]
b = [5,4,3,2,1]
c = []
for i,j in zip(a,b):
c.append(i+j)
ตัวอย่างต่อมา มีการทำงานเหมือนตัวอย่างแรกทุกประการ แต่ใช้ Numerical Arithmetic ที่การบวกไม่ต้องเข้าถึงสมาชิกใน Array
from numpy import *
a = array([1,2,3,4,5])
b = array([5,4,3,2,1])
c = a+b
จะเห็นได้ว่า การเขียนโปรแกรมแบบ Numerical อำนวยความสะดวกในการเขียนโปรแกรมได้ค่อนข้างมาก โดยเฉพาะอย่างยิ่ง โปรแกรมที่มีการคำนวนที่ซับซ้อนมาก ๆ ภาษาเขียนโปรแกรมที่รองรับการเขียนโปรแกรมแบบ Numerical มีเพียงไม่กี่ภาษาเท่านั้น ได้แก่
MATLAB เข้าใจว่าเป็นภาษาแรก ที่รองรับ การเขียนโปรแกรมลักษณะนี้ ส่วน Octave และ SciLab ก็ถือว่าเป็นภาษา MATLAB แต่มี Implementation ที่ต่างออกไป
Python ด้วยโมดูล Numpy
FORTRAN 90 แต่ไม่ใช่ Arithmetic หลัก และยังขาดอีกหลาย ๆ Features
C++ ด้วย Blitz++
จะเน้น Python+Numpy และ MATLAB เป็นหลัก ซึ่งการเขียนโปรแกรมทั้งสองภาษามีความท้าทายอยู่ที่ จะทำอย่างไรถึงจะใช้ for loop ให้น้อยที่สุด การลด for loop เป็นเรื่องที่ค่อนข้างจำเป็น ในการเขียนโปรแกรมแบบ Numerical เพราะนอกจากจะทำให้โปรแกรมสั้นลง และอ่านง่ายขึ้นแล้ว ในกรณีของ Python+Numpy และ MATLAB ยังทำให้ความเร็วของโปรแกรมเพิ่มขึ้นอีกด้วย (อย่างน้อยห้าเท่า แต่โดยปกติยี่สิบ ถึงห้าสิบเท่า)
การเขียนโปรแกรมแบบ Numerical ต่างจากการเขียนโปรแกรมแบบ Procedure ค่อนข้างมาก การจะลด for loop ได้นั้น ต้องรู้เคล็ดไม่ลับต่าง ๆ พอสมควร
หลักการเขียน
1 Initial
การสร้าง Array หรือ Matrix นั้น มีวิธีการอยู่มากมายหลายวิธีด้วยกัน วิธีที่พื้น ๆ ที่สุด คือ กำหนดค่าสมาชิกต่าง ๆ ใน Array หรือ Matrix ด้วยตัวเอง หาก Array หรือ Matrix มีสมาชิกจำนวนน้อย ๆ ก็ดีไป แต่เมื่อไรที่สมาชิกจำนวนมากขึ้น ก็พิมพ์กันนิ้วบวมเหมือนกัน ยกตัวอย่างเช่น
# Python + Numpy
from numpy import *
# สร้าง Array
a = array([1,2,3,4,5])
# สร้าง 2D Array
a = array([[1,2,3,4,5], [6,7,8,9,10]])
# สร้าง 3D Array
a = array([[[1,2,3,4,5], [6,7,8,9,10]],[[1,2,3,4,5], [6,7,8,9,10]]])
# สร้าง Matrix
b = matrix('1 2 3;0 0 1;1 12 0')
# สร้าง Matrix
b = matrix([[1, 2, 3], [0, 0, 1], [1 12 0]])
# สร้าง Matrix จาก Array
b = matrix([a,a,a])
Ex2
% MATLAB
% สร้าง 1D Matrix แนวนอน
a = [1,2,3,4,5]
% สร้าง 1D Matrix แนวตั้ง
a = [1;2;3;4;5]
% สร้าง 2D Matrix
b = [[2,3,4];[4,5,6];[6,7,8]];
หมายเหตุ จะเห็นได้ว่า MATLAB และ Numpy มีความคล้ายคลึงกันพอสมควร แต่มีจุดต่างที่สำคัญมากคือ Numpy แยกระหว่าง Array และ Matrix โดย Operation ระหว่าง Array จะเป็นแบบ สมาชิกต่อสมาชิก (elementwise operation) และจะมีกี่มิติก็ได้ ส่วน Matrix จะเป็นแบบ Linear Algebra ที่มี 1 หรือ 2 มิติ แต่ใน MATLAB มองทุกอย่างเป็น Matrix ที่มี 1 หรือ 2 มิติ
วิธีสร้าง Array หรือ Matrix แบบต่อมา เป็นการสร้างแบบเรียงลำตับตัวเลข เช่น 1-100 หรือ กลับหลังเป็น 100-1 เป็นต้น ซึ่งวิธีนี้ใน MATLAB ค่อนข้างง่ายกว่า Numpy เพราะใช้แค่เครื่องหมาย : ส่วนใน Numpy ต้องเรียกใช้ฟังก็ชัน arange(), r_[], c_[] ซึ่งค่อนข้างยุ่งยากและสับสนพอสมควร
ประโยชน์ของการสร้าง Array ในลักษณะนี้คือ การนำ Array ที่ได้ไปเป็น แกน x หรือ แกน y ในการแทนค่าผ่านฟงก์ชันหนึ่ง ๆ ยกตัวอย่างเช่น เราอยากรู้ค่าของ sin(x) ที่ x มีค่าตั้งแต่ -10 ถึง 10 เราก็สร้างแกน x ที่มีค่าตามที่ต้องการ แล้วนำแกน x ที่ได้ ไปหาค่าฟังก์ชัน เป็นต้น ต่อไปนี้คือตัวอย่างการใช้งานครับ
>>> from numpy import *
>>> # สร้าง Array ที่มีค่าตั้งแต่ -10 ถึง 10 โดยสมาชิกแต่ละตัว มีค่าห่างกัน 0.5
>>> x = arange(-10,10,0.5)
>>> y = sin(x) # คำนวนหาค่า ฟังก์ชั่นผ่านแกน x
>>> # r_[begin:end:interval] เหมือน arange() ทุกประการ ในกรณีนี้ สร้างแกน x แบบกลับด้าน
>>> x = r_[10:-10:-0.5]
>>> # c_[] คล้าย ๆ r_[] แต่สามารถสร้าง Muti Dimension Array ได้
>>> x = c_[1:5,2:6]
>>> y = x**2 + 3*x + 4 # คำนวนค่า พหุนาม
>>> # สร้าง Matrix จาก c_[] แล้วนำค่าที่ได้มาคูณกัน
>>> x = matrix(c_[1:5,2:6]) * matrix(c_[1:5,2:6]).T
Ex2
>> % เหมือนตัวอย่างแรกใน python เกือบทุกประการ แต่ใน MATLAB จะรวมค่าสุดท้ายลงไปในผลที่ได้ด้วย
>> % Syntax begin:interval:end
>> x = -10:0.5:10;
>> y = sin(x);
>> % สร้าง Matrix ในเครื่องหมาย ; คั่นระหว่าง row
>> x = [1:5;2:6] ;
วิธีสร้าง Array หรือ Matrix อีกแบบคือ การสร้าง Array หรือ Matrix ที่เป็นค่าคงที่ นั่นหมายความว่า สมาชิกทุกตัวใน Array หรือ Matrix มีค่าเดียวกันหมด ค่าคงที่ที่มักถูกนำมาใช้บ่อย ๆ คือ ศูนย์ และ หนึ่ง เพราะทั้งสองค่า เป็นคุณสมบัติการบวก และการคูณตามลำดับ ใน MATLAB และ Numpy จึงมีฟังก์ชั่นที่ใช้สร้าง Array หรือ Matrix ที่มีค่า ศูนย์ หรือ หนึ่งโดยเฉพาะ ซึ่งเราสามารถดัดแปลงเป็นการสร้าง Array ค่าคงตัวอื่น ๆ ได้ ด้วยการบวก หรือคูณค่าคงตัวอื่น ๆ จาก Array ที่ได้
การสร้าง Array ลักษณะนี้ จะถูกนำมาใช้งานร่วมกับ Array Slicing และ Conditioning ในกรณีที่ เราต้องการเก็บค่าที่ได้จากการคำนวน ไว้ในสมาชิกของ Array ที่เราต้องการ โดยที่เรารู้ขนาดของ Array ล่วงหน้า (อ่านแล้วงง ๆ เอาเป็นว่าดูตัวอย่าง ใน Slicing และ Condition อีกที)
>>> from numpy import *
>>> # สร้าง Array หนึ่งมิติ มีสมาชิสิบตัว และสมาชิกทุกตัวมีค่าเป็นศูนย์
>>> a = zeros(20)
>>> # เหมือนตัวอย่างแรก แต่กำหนดประเภทตัวแปร เป็นจำนวนเชิงซ้อน
>>> a = zeros(20, dtype=complex64)
>>> # เหมือนตัวอย่างที่สอง แต่ เป็น Array สองมิติ ขนาด 10x10
>>> a = zeros((10,10), dtype=complex64)
>>> # เหมือนตัวอย่างที่สาม แต่สมาชิกทุกตัวมีค่าเป็นหนึ่ง
>>> a = ones((10,10), dtype=complex64)
>>> # เหมือนตัวอย่างที่สี่ แต่ เป็น Array สามมิติ ขนาด 10x10x10
>>> a = ones((10,10,10), dtype=complex64)
>>> # เหมือนตัวอย่างที่ห้า แต่สมาชิกทุกตัวมีค่าเป็น pi และ เป็นตัวแปรประเภท float
>>> a = ones((10,10,10)) * pi
Ex2
>> % สร้าง Matrix ขนาด 10x10 สมาชิกทุกตัวมีค่าเป็นศูนย์
>> a = zeros(10) ;
>> % สร้าง Matrix ขนาด 1x10 สมาชิกทุกตัวมีค่าเป็นศูนย์
>> a = zeros(1,10) ;
>> % สร้าง Matrix ขนาด 10x1 สมาชิกทุกตัวมีค่าเป็นศูนย์
>> a = zeros(10,1) ;
>> % สร้าง Matrix ขนาด 10x1 สมาชิกทุกตัวมีค่าเป็นหนึ่ง
>> a = ones(10,1) ;
>> % สร้าง Matrix ขนาด 10x1 สมาชิกทุกตัวมีค่าเป็นหนึ่ง
>> a = ones(10,1) ;
>> % สร้าง Matrix ขนาด 10x1 สมาชิกทุกตัวมีค่าเป็น pi
>> a = ones(10,1)*pi;
>> % สร้าง Matrix ขนาด 10x1 สมาชิกทุกตัวมีค่าเป็น 0 + 1i (จำนวนเชิงซ้อน)
>> a = zeros(10,1) + i*ones(10,1)
การสร้าง Array แบบสุดท้ายที่ผมจะนำเสนอ คือ การสร้าง Array แบบสุ่ม ซึ่งสามารถนำไปใช้ประโยชน์ได้ค่อนข้างมาก โดยเฉพาะใน Simulation ซึ่ง Array แบบสุ่ม ที่มักถูกนำมาใช้บ่อย ๆ มีด้วยกันสองแบบคือ Normal Distribution กับ Uniform Distribution ส่วน Distribution อื่น ๆ นั้น มีให้เลือกใช้มากมาย ทั้งใน Numpy และ MATLAB แต่ผมรู้สึกว่าของ MATLAB เจ๋งกว่าของ Numpy พอสมควร
>>> from numpy import *
>>> # การสร้าง Array แบบสุ่ม ต้องการโมดูลแยกต่างหาก
>>> from numpy.random import *
>>> # Uniform Distribution สมาชิกมีค่าตั้งแต่ 0-1 ขนาด 100000
>>> a = random(100000)
>>> # Uniform Distribution สมาชิกมีค่าตั้งแต่ 0-1 ขนาด 100x100
>>> a = random((100,100))
>>> # Uniform Distribution (Integer) สมาชิกมีค่าตั้งแต่ -10-10 ขนาด 100x100
>>> a = randint(-10,10, (100,100))
>>> # Normal Distribution ขนาด 100x100 , Mean = 0, Sigma = 1
>>> a = normal(0,1,(100,100))
Ex2
>> % Uniform Distribution สมาชิกมีค่าตั้งแต่ 0-1 ขนาด 1x100000
>> a = random('uniform',0,1,1,100000);
>> % Uniform Distribution สมาชิกมีค่าตั้งแต่ 0-1 ขนาด 100x100
>> a = random('uniform',0,1,100,100);
>> % Uniform Distribution (Integer) สมาชิกมีค่าตั้งแต่ 0-1 ขนาด 100x100
>> a =floor(random('uniform',-10,10,100,100));
>> % Normal Distribution ขนาด 1x100000 , Mean = 0, Sigma = 1
>> a = random('normal',0,1,1,100000);
2 Slicing
เมื่อสร้าง Array ได้แล้ว ปัญหาต่อมาคือ เราจะนำสมาชิกที่อยู่ใน Array มาใช้ได้อย่างไร โดยปกติหากเรานำตัวแปร Array มาใช้ โดยที่ไม่ได้ระบุการเข้าถึงสมาชิก หมายความว่า เราต้องการคำนวน โดยใช้ค่าจากสมาชิกทุกตัว ซึ่งเป็นการคำนวนแบบ Numerical ทั่ว ๆ ไป แต่ก็มีการคำนวนหลาย ๆ กรณี ที่เราต้องการค่าบางค่าของ Array มาใช้ ซึ่งกรณีเหล่านี้ สามารถกำหนดได้โดย Slicing และ Conditioning
การเลือกสมาชิกใน Array โดย Slicing นั้น เราสามารถกำหนดได้โดยพาราเมเตอร์สามตัวคือ Index ของสมาชิกตัวแรก ที่เรา ต้องการเลือก (begin) ความห่างของ Index ระหว่างสมาชิกแต่ละตัว ที่เราต้องการเลือก (interval) และ Index ของสมาชิกตัวสุดท้ายที่เราต้องการเลือก (end) ระหว่าง MATLAB และ Numpy นั้น มีข้อแตกต่างกันเล็กน้อยคือ MATLAB จะเรียงลำดับการ Slicing เป็น begin:interval:end ส่วน Numpy จะเป็น begin:end:interval
นอกจากนี้ใน Numpy ยังมี Syntax ที่ค่อนข้างยืดหยุ่นกว่า MATLAB กล่าวคือ เราสามารถละค่า begin, end และ interval ได้ การละค่าดังกล่าว เท่ากับเรากำหนดค่าต่าง ๆ เป็นค่าปริยาย โดยค่าปริยายมีค่าดังนี้ begin=1 ในกรณีที่ interval มีค่าเป็นบวก และมีค่าเป็นขนาดของ Array-1 ในกรณีที่ interval มีค่าเป็นลบ ส่วน end มีค่ากลับกัน และ interval มีค่าปริยายเป็น -1
>>> from numpy import *
>>> # สร้าง Array ที่มีค่าสมาชิกตั้งแต่ 0 - 9999
>>> a = arange(10000)
>>> # เลือกสมาชิก Array ที่มีค่า Index เป็น เลขคู่
>>> a[::2]
>>> # เลือกสมาชิก Array ที่มีค่า Index เป็น เลขคี่
>>> a[1::2]
>>> # Inverse ของ Array
>>> a[::-1]
>>> # เลือกสมาชิกของ Array ทุกตัว ยกเว้น 20 ค่าสุดท้าย
>>> a[:-20]
>>> # เลือกสมาชิกของ Array ยกเว้น 20 ค่าสุดท้าย และ 10 ค่าแรก เรียง Index จากมากไปหาน้อย
>>> a[-20:10:-1]
>>> # สร้าง Array สองมิติ ขนาด 2x100 ที่ column แรกสมาชิกมีค่าตั้งแต่ 0 -99 และ column ที่สองสมาชิกมีค่าตั้งแต่100-1
>>> b = c_[:100,100:0:-1]
>>> # เลือกค่าทุกค่าใน row แรก
>>> b[0,:]
>>> # เลือกค่าทุกค่าใน column แรก
>>> b[:,0]
Ex2
>> % สร้าง Matrix ที่มีค่าสมาชิกตั้งแต่ 1 - 10000
>> a = 1:10000;
>> % เลือกสมาชิก Matrix ที่มีค่า Index เป็น เลขคี่
>> a(1:2:end)
>> % เลือกสมาชิก Matrix ที่มีค่า Index เป็น เลขคู่
>> a(2:2:end)
>> % Inverse ของ Matrix
>> a(end:-1:1)
>> % เลือกสมาชิกของ Matrix ทุกตัว ยกเว้น 20 ค่าสุดท้าย
>> a(1:1:end-20)
>> % สร้าง Array สองมิติ ขนาด 100x2 ที่ row แรกสมาชิกมีค่าตั้งแต่ 1 -100 และ row ที่สองสมาชิกมีค่าตั้งแต่ 100-1
>> b = [1:1:100;100:-1:1]
>> % เลือกค่าทุกค่าใน row แรก
>> b(1,1:end)
>> % เลือกค่าทุกค่าใน column แรก
>> b(1:end,1)
ตัวอย่างต่อไปนี้ เป็นการเปลี่ยนจาก Bit-Array ที่ประกอบด้วยค่า 1 และ 0 เป็นสัญญาณรูป Sine (sin(x)) โดยค่า Bit-Array หนึ่งค่า จะถูกแปลงเป็นค่าสัญญาน 32 ค่า (32 Samples per Bit) โดยมีเงื่อนไขว่า หาก Bit มีค่าเป็น 0 สัญญาณจะมีค่าเป็น -sin(x) และหาก bit มีค่าเป็น 1 สัญญาณจะมีค่าเป็น sin(x) เนื่องจากโค้ดของ Numpy และ MATLAB คล้ายกันมาก ผมเลยขอละ โค้ดของ MATLAB เอาไว้
>>> from numpy import *
>>> from numpy.random import *
>>> # กำหนดจำนวน bit ของ Bit-Array
>>> nbit = 10000
>>> # กำหนดจำนวน Samples per bit ของ สัญญาณ
>>> sample = 32
>>> # สร้าง Bit-Array ด้วยการสุ่ม
>>> bit = randint(0,2,nbit)
>>> # สร้างสัญญาณพื้นฐาน
>>> sig = sin(arange(sample*nbit)*pi/16)
>>> # คำนวนค่า prefix หาก bit == 1 => prefix = 1 , bit == 0 => prefix = -1
>>> prefix = bit*2 -1
>>> # คำนวนค่าสัญญาณ
>>> for i in range(sample) : sig[i::sample] = prefix*sig[i::sample]
ตัวอย่างต่อมา คล้าย ๆ กับตัวอย่างก่อนหน้านี้ แต่ Bit-Array เป็น Array สองมิติ และสัญญาณที่ได้เป็นสัญญาณเชิงซ้อน โดยค่าของ ฺBit-Array ใน row ที่หนึ่ง จะถูกแปลงเป็นส่วนจริงของสัญญาณ และ ค่าของ ฺBit-Array ใน row ที่สอง จะถูกแปลงเป็นส่วนจินตภาพของสัญญาณ นอกจากนี้ ยังกำหนดให้ฟังก์ชันพื้นฐานของส่วนจิตภาพของสัญญาณ เป็น Cosine แทนที่จะเป็น Sine อีกด้วย
>>> from numpy import *
>>> from numpy.random import *
>>> nbit = 10000
>>> sample = 32
>>> bit = randint(0,2,(2,nbit))
>>> # สร้างสัญญาณพื้นฐาน เป็นสัญญาณเชิงซ้อน
>>> sig = sin(arange(sample*nbit)*pi/16) + 1j * cos(arange(sample*nbit)*pi/16)
>>> prefix = bit*2 -1
>>> # คำนวนค่าสัญญาณ โดยใช้การ Slicing แบบสองมิติ และแยกคำนวนระหว่างส่วนจริง และส่วนจิตภาพ
>>> for i in range(sample) : sig[i::sample] = prefix[0,:]*sig[i::sample].real + 1j*prefix[1,:]*sig[i::sample].imag
เพื่อแสดงให้เห็นถึงข้อแตกต่าง ตัวอย่างต่อไปนี้เป็นโปรแกรมเดียวกัน กับตัวอย่างก่อนหน้านี้ แต่ใช้ List ของ Python แทน Array ในการคำนวน แม้ว่า List ของ Python จะสามารถ slice ได้ แต่ก็ไม่สามารถคำนวนในรูปแบบ Numerical ได้ ดังนั้นเราจึงต้องใช้ for loop ในการเข้าถึงสมาชิกทุกตัว ผลที่ได้คือ โค้ดที่มีความยาวมากขึ้น และยังใช้เวลาในการคำนวน มากกว่าการคำนวนแบบ Numerical ถึงแปดเท่า
>>> from random import *
>>> from math import *
>>> nbit = 100000
>>> sample = 32
>>> bit = [[],[]]
>>> for i in xrange(nbit):
... bit[0].append(randint(0,2))
... bit[1].append(randint(0,2))
>>> sig = []
>>> for i in xrange(sample*nbit):
... sig.append( sin(i*pi/16) + 1j*cos(i*pi/16))
>>> prefix = bit
>>> for i in xrange(nbit):
... prefix[0][i] = bit[0][i]*2 - 1
... prefix[1][i] = bit[1][i]*2 - 1
>>> for i in xrange(nbit) :
... for j in xrange(sample):
... sig[i*sample + j] = prefix[0][i]*sig[i*sample + j].real + 1j*prefix[1][i]*sig[i*sample + j].imag
ตัวอย่างสุดท้าย เป็นตัวอย่างที่แสดงให้เห็นถึงประโยชน์ของการใช้งาน zeros ร่วมกับ Slicing โดยในตัวอย่างนี้ เราต้องการหา Array ที่มีลักษณะสมมาตร (symmetry) โดยในขั้นแรก เราสร้าง Array ที่มีขนาดครึ่งนึง ของขนาด Array ที่เราต้องการก่อน จากนั้นเราจึงคำนวนค่าฟังก์ชัน จาก Array ดังกล่าว แล้วจึงส่งค่าที่ได้ ไปยัง Array ที่เราต้องการ โดยใช้ Slicing
>>> from numpy import *
>>> x = sin(arange(0,10,0.01))
>>> y = zeros(2*x.shape[0], dtype=float32)
>>> y[:x.shape[0]] = 1*x
>>> y[x.shape[0]:] = 1*x[::-1]
3 Conditioning
Conditioning คือ การเข้าถึงสมาชิกของ Array โดยมีเงื่อนไข หากไม่ใช้ Numerical ในการคำนวน ก็คือ การใช้ if-statement ใน loop นั่นเอง โดยในขั้นแรก เราต้องกำหนดเงื่อนไขกับ Array ที่เราต้องการก่อน ผลที่ได้คือ Array ที่มีสมาชิกเป็นค่า boolean และมีจำนวนสมาชิกเท่ากับ Array ที่เรากำหนดเงื่อนไข จากนั้น เราจึงนำ Array ที่ได้ ไปเป็นตัวกรอง สำหรับ Array ที่เราต้องการเลือกค่า ซึ่งต้องมีจำนวนสมาชิกเท่ากับ Array เงื่อนไข ผลที่ได้คือ Array อีกตัวหนึ่ง ซึ่งใช้ตรรกะจาก Array เงื่อนไข ในการเลือกสมาชิก จาก Array เลือกค่า อ่านแล้วงงเหมือนเดิม ดูตัวอย่างดีกว่าครับ
>>> from numpy import *
>>> from math import *
>>> a = normal(0,1,1000)
>>> # สร้าง Array เงื่อนไข ที่มีค่าเป็น True เมื่อ สมาชิกของ a มีค่ามากกว่า 0
>>> cond = a > 0
>>> # สร้าง Array ที่มีคุณสมบัติเหมือน a แต่สมาชิกทุกตัวมีค่าเป็นศุนย์
>>> c = zeros_like(a)
>>> # สำหรับ a ที่มีค่ามากกว่า ศูนย์ ให้หาค่า sin ของ a แล้วเก็บไว้ใน c
>>> c[cond] = sin(a[cond])
>>> # สำหรับ a ที่มีค่าน้อยกว่า ศูนย์ ให้หาค่า cos ของ a แล้วเก็บไว้ใน c
>>> c[~cond] = cos(a[~cond])
Ex2
>> % การคำนวนเหมือนตัวอย่างใน Numpy ทุกประการ
>> a = random('normal',0, 1, 1, 1000);
>> cond = a > 0;
>> c = zeros(size(a));
>> c(cond) = sin(a(cond));
>> c(~cond) = sin(a(~cond));
ตัวอย่างต่อไปนี้ เป็นตัวอย่างคล้าย ๆ กับตัวอย่างการสร้างสัญญาณใน Array Slicing แต่แทนที่จะสร้างสัญญาณเป็นรูป sin ก็สร้างสัญญาณเป็นรูป Gauss แทน จากนั้นจึงบวกค่า Noise ลงไปในสัญญาณ จากนั้นก็กรองสัญญาณด้วย Gauss-Filter แล้วจึงมาคำนวนกลับเป็นค่า bit อีกครั้งหนึ่ง ค่า bit ที่ได้ จะถูกนำไปเปรียบเทียบกับค่า bit ที่ถูกสร้างขึ้นในตอนแรก เพื่อคำนวนหาอัตราข้อผิดพลาดของการส่งสัญญาณ แม้ว่าจะเป็นตัวอย่างที่ค่อนข้างซับซ้อน แต่ก็แสดงการนำเทคนิคต่าง ๆ มาใช้งานได้ดีทีเดียว
#!/usr/bin/python
# -*- coding: utf-8 -*-
from numpy import *
from numpy.random import *
from numpy.fft import *
# Gauss low pass filter
def gauss_lp(dimen):
# คำนวน Gauss Filter
return roll( exp(-0.5*arange(-8,8,16/float(dimen), dtype=complex64)**2), dimen/2)
def get_signal_error():
nbit = 100000
sample = 32
bit = randint(0,2,(2,nbit))
prefix = (bit[0]*2-1) + 1j*(bit[1]*2 -1)
sig = zeros(sample*nbit, dtype=complex64)
# คำนวน Gauss-Impulse (สัญญาณรูประฆังคว่ำ)
impulse = exp(-0.5*arange(-4,4,0.25)**2)
for i in range(sample) :
# แปลง Bit เป็นสัญญาณรูป Gauss
sig[i::sample] = impulse[i]*prefix
# คำนวนสัญญาณรบกวน
noise = normal(0,0.75,nbit*sample) + 1j*normal(0,0.25,nbit*sample)
# บวกสัญญาณรบกวรลงไปในสัญญาณ
sig += noise
# กรองสัญญาณด้วย Gauss-Filter
sig = ifft(fft(sig)*gauss_lp(sample*nbit))
# คำนวนหา Bit ที่ได้จากสัญญาณ หากสัญญาณมีค่ามากกว่า 0 => Bit = 1
bitOut = array([ 1*( sig[16::32].real > 0), 1*( sig[16::32].imag > 0)])
# หาจำนวน Bit ที่ผิดพลาด โดยเปรียบเทียบ Bit ขาเข้า กับ Bit ขาออก
BER = sum(sum(bit != bitOut)) / (2.0*nbit)
print 'Bit Error Rates = %.5f '%BER
if __name__ == '__main__' : get_signal_error()
แม้ว่าโปรแกรมในตัวอย่างสุดท้าย (หรือตัวอย่างอื่น ๆ ) สามารถใช้การเขียนโปรแกรมแบบที่เรารู้จักกันทั่วไป แก้ปัญหาได้ (ทั้ง Numpy และ MATLAB) แต่ขนาดของโปรแกรมต้องมีขนาดใหญ่กว่าหลายเท่า และที่สำคัญ โปรแกรมที่ได้มีความเร็วต่ำกว่าการใช้ Numerical มาก
การควบคุมเชิงตัวเลขด้วยคอมพิวเตอร์ ( CNC )
การควบคุมเชิงตัวเลขด้วยคอมพิวเตอร์ หรือที่รู้จักกันในชื่อของ CNC ( Computerized Numerical Control ) นั้น
เป็นการประยุกต์ใช้ความสามารถขั้นสูงของระบบควบคุมที่ประมวลผลเชิงตัวเลข ซึ่งมีคอมพิวเตอร์เป็นอุปกรณ์หลัก
ในการประมวลผลความเร็วสูง โดยนำมาใช้กับการควบคุมกระบวนการทำงานของเครื่องจักรในอุตสาหกรรมการผลิต
ดังนั้น จึงอาจกล่าวได้ว่า CNC คือ การควบคุมเครื่องจักรกลด้วยคอมพิวเตอร์ ซึ่งจะต้องทำการเขียนชุดคำสั่ง หรือ
โปรแกรมสำหรับควบคุมเครื่องจักรด้วย โดยทั่วไปแล้ว นิยมเรียกรวมทั้งระบบควบคุมและเครื่องจักรว่า เครื่อง CNC
ปัจจุบัน มีการนำความสามารถด้านการควบคุมของฟัซซี่ลอจิกมาผนวกใช้กับ CNC เพื่อช่วยเพิ่มความถูกต้องแม่นยำ และปรับแต่งค่าต่างๆในการควบคุมการทำงานของเครื่อง CNC ด้วย
การเลือกซื้อ CNC มาใช้งานนั้นเราต้องดูก่อน ว่างานของเรานั้นขึ้นรูปด้วยกรรมวิธีการผลิตแบบใด หลักๆ นั้นเครื่อง CNC ที่ใช้ทั่วไปพื้นฐานนั้นก็คือ เครื่องกลึง และ เครื่องกัด สำหรับหลักการเบื้องต้นนั้น จะเลือกเครื่องจักรดังนี้
1. ประเภทของงาน วัสดุที่ใช้สร้างชิ้นงาน(เหล็ก อะลูมิเนียม หรือไม้ )
2. ขนาดของงาน เลือกเครื่องจักรที่มี table ที่ใหญ่กว่าชิ้นงาน เลือกใหญ่ๆ ไว้ก็ดี เพราะเผื่อทำงานที่มีขนาดใหญ่ๆ ได้
3. ความละเอียดในการสร้างชิ้นงาน ต้องดูก่อนว่างานของเรานั้นต้องการ precission มากน้อยแค่ไหน โดยปกติแล้วในระดับ 0.1 mm (100 ไมครอน) ก็น่าจะเหมาะสม นอกเสียจากว่าต้องการละเอียดในระดับ 10-50 ไมครอน ก็ต้องเลือกเครื่องจักรที่ละเอียดหน่อย
4. ความเร็วรอบของหัวจับ หรือหัวกัด รวมถึงกำลังของเครื่องจักร ด้วย
การควบคุมเครื่องจักรด้วยระบบเชิงตัวเลข โดยจัดหาและประมวลผลด้วยคอมพิวเตอร์ กล่าวคือ ระบบควบคุมแบบนี้จะมีคอมพิวเตอร์ที่มีความสูงเพิ่มขึ้นเข้าไปในระบบเพื่อทำให้สามารถจัดการกับข้อมูลที่ป้อนเข้าไปในระบบนี้ ตลอดจนสามารถประมวลผลข้อมูลเพื่อนำผลลัพธ์ที่ได้ไปควบคุมการทำงานของเครื่องจักร
ตัวอย่างของ CNC
การทำงานของปริ้นเตอร์
การทำงานของเครื่องพิมพ์
1. Initailized เครื่องพิมพ์ โดย
1. เครื่องคอมพิวเตอร์จะส่งสัญญาณ Reset ไปที่ Printer Card
2. Printer Card จะส่งสัญญาณ Reset ผ่าน Parallel Port ไปที่เครื่องพิมพ์
3. Printer Card จะส่งสัญญาณ STROBS ผ่าน Parallel Port ไปที่เครื่องพิมพ์ ไฟ Online ที่เครื่องพิมพ์จะติด และเครื่องพิมพ์จะส่งสัญญาณ Select กลับมาที่ Printer Card และ Printer Card จะส่งสัญญาณ I/O CH RDY ไปที่เครื่องคอมพิวเตอร์ ซึ่งจะแสดงว่าเครื่องพิมพ์พร้อมทำงาน
2. การพิมพ์งานออกจากเครื่องพิมพ์
1. เครื่องคอมพิวเตอร์จะส่งสัญญาณ IRQ 7 ไปที่ Printer Card
2. เครื่องคอมพิวเตอร์จะส่งสัญญาณ I/O W ไปที่ Printer Card
3. Printer Card จะส่งสัญญาณ I/O CH RDY ไปที่เครื่องคอมพิวเตอร์ เพื่อจะแสดงว่าเครื่องพิมพ์พร้อมรับข้อมูล
4.เมื่อเครื่องคอมพิวเตอร์ได้รับสัญญาณ I/O CH RDY จะส่งข้อมูลผ่านพอร์ตขนาน ไปที่ Printer Card
5. เครื่องพิมพ์จะส่งสัญญาณ Select ไปที่ Printer Card เพื่อจะแสดงว่าเครื่องพิมพ์พร้อมรับข้อมูล
6. Printer card จะส่งข้อมูล Buffer ของเครื่องพิมพ์ เพื่อพิมพ์งานตามลำดับ
7. เครื่องพิมพ์จะส่งสัญญาณ ACK ไปที่ Printer Card เพื่อจะแสดงว่าเครื่องพิมพ์ได้รับข้อมูลแล้ว
8. เครื่องพิมพ์จะส่งสัญญาณ BUSY ไปที่ Printer Card เพื่อจะแสดงว่าเครื่องพิมพ์กำลังพิมพ์งานอยู่ ไม่ว่างที่จะรับข้อมูลใหม่ได้อีกจนกว่าจะพิมพ์งานเสร็จ
3. ถ้าเกิดปัญหาระหว่างการพิมพ์ จะมีการทำงานดังนี้
1. ถ้ากระดาษหมด paper out sensor ในเครื่องพิมพ์จะตรวจพบ และส่งสัญญาณ Paper Out ไปที่ Printer Card ไฟสัญญาณแสดงสถานะกระดาษจะติด หรือ ถ้ากระดาษติดขัด หรือกลไกขัดข้อง sensor จะส่งสัญญาณ Error ไปที่ Printer Card
2. เครื่องพิมพ์จะส่งสัญญาณ select เป็น 0 ไฟ online จะดับ
4. Printer Card จะส่งสัญญาณ I/O CH RDY เป็น 0 เพื่อแสดงว่าเครื่องพิมพ์ไม่พร้อมที่จะทำงาน
ภาพวงจรการทำงานของปริ๊นเตอร์
อ้างอิง
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.