ตำแหน่งหน่วยประมวลผล
ตำแหน่งหน่วยประมวลผลเป็นขั้นตอนการเขียนโปรแกรมออฟไลน์เพราะอนุญาตความยึดหยุ่นในการสนับสนุนหุ่นยนต์ควบคุม ตำแหน่งหน่วยประมวลผลหุ่นยนต์ถูกนิยามว่าโปรแกรมหุ่นยนต์จะต้องถูกสร้างขึ้นเพื่อหุ่นยนต์ควบคุมเฉพาะ
การแปลงจากการจำลอง RoboDK เพื่อโปรแกรมหุ่นยนต์เฉพาะถูกทำให้เสร็จโดยหน่วยประมวลผล หุ่นยนต์แต่ละตัวมีหน่วยประมวลผลซึ่งออกแบบมาตั้งแต่เริ่มต้น หน่วยประมวลผลถูกใช้เมื่อโปรแกรมถูกสร้างขึ้นออฟไลน์ในส่วน Generate Program(โดยการกดที่โปรแกรม,จากนั้น,การเลือกสร้างโปรแกรมหุ่นยนต์)
RoboDK มาจากหน่วยประมวลผลซึ่งสนับสนุนจากหุ่นยนต์ควบคุมหลายตัว, รายชื่อในส่วน Available Post Processors อีกทางเลือกหนึ่ง,มีความเป็นไปได้ที่จะสร้างหน่วยประมวลผลแบบกำหนดเองหรือดัดแปลงหน่วยประมวลผลที่มี หน่วยประมวลผลที่ใช้ได้ทั้งหมดอยู่ในโฟลเดอร์:
C:/RoboDK/Posts/
หน่วยประมวลผลหนึ่งคือไฟล์PY (แต่ละหน่วยประมวลผลถูกกำหนดด้วยต้นฉบับ Python) นอกจากนี้ยังสามารถเพิ่ม, ดัดแปลงหรือลบไฟล์ในโฟลเดอร์PostsของRoboDK ถ้าคุณได้จัดหาหน่วยประมวลผลของ RoboDK เรียบร้อยแล้ว (ไฟล์ PY) มันควรจะถูกวางในตำแหน่งโฟลเดอร์ซึ่งมันสามารถถูกเลือกจาก RoboDK
ในส่วนนี้แสดงการเลือก, แก้ไขและสร้างหน่วยประมวลผลและใช้มันกับหุ่นยนต์ของคุณใน RoboDKการเริ่มต้นที่รวดเร็วสามารถใช้ได้ในวิดีโอต่อไปนี้:
https://robodk.com/help#PostProcessor
การเลือกหน่วยประมวลผล
การเลือกหน่วยประมวลผลสำหรับหุ่นยนต์:
1.คลิกขวาที่หุ่นยนต์หรือโปรแกรม
2.เลือกSelect Post Processor
3.เลือกหน่วยประมวลผลจากรายการ
4.เลือก OK
การเปลี่ยนแปลงได้ถูกใช้และโปรแกรมสามารถถูกสร้างอีกครั้งเพื่อเห็นผลลัพธ์
โดยมีทางเลือก, สามารถเลือกหน่วยประมวลผลจากขั้นตอนต่อไปนี้
1.เปิดแผงหน้าปัดหุ่นยนต์ (ดับเบิ้ลคลิกที่หุ่นยนต์)
2.เลือกParameters
3.เลือกหน่วยประมวลผลในกล่องยี่ห้อหุ่นยนต์ตามที่แสดงในรูปดังต่อไปนี้
ตัวแก้ไขหน่วยประมวลผล
คุณสามารถเปลี่ยนการตั้งค่าของหน่วยประมวลผลได้อย่างง่ายดายผ่านอินเทอร์เฟซผู้ใช้แบบกราฟิก ตัวแก้ไขหน่วยประมวลผลช่วยให้คุณเปลี่ยนตัวแปรที่กำหนดไว้ในหน่วยประมวลผลซึ่งเฉพาะเจาะจงกับตัวควบคุมหุ่นยนต์ของคุณได้
ตัวแก้ไขหน่วยประมวลผลเป็นปลั๊กอินที่ช่วยให้คุณปรับแต่งหน่วยประมวลผลของคุณ คุณสามารถดาวน์โหลดและติดตั้งปลั๊กอินนี้ได้อย่างง่ายดายจากหน้าเว็บต่อไปนี้: https://robodk.com/addin/com.robodk.plugin.postprocessoreditor.
ทำตามขั้นตอนต่อไปนี้เพื่อเปิดตัวแก้ไขหน่วยประมวลผล:
1.เลือก Program→Post Processor Editor
2.เลือกหน่วยประมวลผลที่คุณต้องการปรับแต่ง
3.เลือก OK หน้าต่างใหม่จะเปิดขึ้นแสดงตัวแปรที่สามารถแก้ไขได้
4.เลือก Save Post Processor as…
5.ป้อนชื่อที่ต้องการใช้บันทึก
ตัวอย่างเช่น หากคุณเลือกหน่วยประมวลผล Fanuc R30iA คุณจะเห็นหน้าต่างที่แสดงในภาพก่อนหน้านี้
การดัดแปลงหน่วยประมวลผล
อีกทั้งยังสามารถดัดแปลงหน่วยประมวลผลหรือสร้างหน่วยประมวลผลขึ้นมาใหม่ หน่วยประมวลผลจะต้องถูกวางในโฟลเดอร์ C:/RoboDK/Posts/ ซึ่งสามารถถูกเลือกได้ใน RoboDK ในส่วนก่อนหน้านี้อธิบายการเชื่อมโยงหุ่นยนต์เฉพาะกับหน่วยประมวลผล
แต่ละหน่วยประมวลผลเป็นไฟล์ PY และสามารถเปลี่ยนชื่อไฟล์และคัดลอกไฟล์จาก/ถึงโฟลเดอร์ C:/RoboDK/Posts/ เพื่อแบ่งปันหน่วยประมวลผลที่แตกต่างกัน เพื่อลบต้นฉบับหน่วยประมวลผลที่มีอยู่, ลบอย่างง่ายด้วยไฟล์ที่เหมือน PY ในตำแหน่งของโฟลเดอร์
หน่วยประมวลผลสามารถแก้ไขโดยใช้ตัวแก้ไขตัวอักษรหรือตัวแก้ไข Python(Python IDLE) การใช้ตัวแก้ไขPython อนุญาตให้แก้ปัญหาตัวอย่างโปรแกรมในตอนสุดท้ายของไฟล์
Python ควรจะถูกติดตั้งเพื่อทดสอบและใช้หน่วยประมวลผลอย่างเหมาะสม (Python ถูกติดติดตั้งเริ่มต้นด้วย RoboDK)
เพื่อดัดแปลงหน่วยประมวลผลที่มีอยู่:
1.เลือก Program➔Add/Edit Post Processor
2.เลือกหน่วยประมวลผลที่มีอยู่
3.เลือกOKตัวแก้ไขอักษรและโปรแกรมจะเปิดขึ้น
4.เลือกRun➔Run module (F5)เพื่อดูผลลัพธ์ ทำการเปลี่ยนแปลงถ้าจำเป็น
อีกทางเลือกหนึ่ง, ยังสามารถแก้ไขหน่วยประมวลผลได้ด้วยตนเอง:
1.ไปที่โฟลเดอร์หน่วยประมวลผล: C:/RoboDK/Posts/
2.เปิดไฟล์PY file ด้วย Python IDLE (คลิกขวา➔แก้ไขด้วย IDLE) หรือตัวแก้ไขอักษรอื่น
3.ทำการเปลี่ยนแปลงที่ต้องการ
4.ดำเนินการเพื่อทดสอบผลลัพธ์: เลือกRun➔Run module (F5 โดยเริ่มต้น) จาก Python IDLE
อีกทางเลือกหนึ่ง, ยังสามารถแก้ไขไฟล์ที่ใช้ตัวแก้ไขอักษรเพื่อดำเนินการ Python โดยการดับเบิ้ลคลิก
ตัวอย่างการดัดแปลง
ในส่วนนี้จะแสดงวิธีการเปลี่ยนแปลงเล็กๆในหน่วยประมวลผล
ดังตัวอย่าง, การเปลี่ยนแปลง3อย่างจะถูกทำในหน่วยประมวลผล KUKA KRC4
●แทนที่ความเร็วสูงสุดถึง 500 mm/s. ถ้าแม้ว่าถ้าหุ่นยนต์ถูกเขียนให้เร็วกว่านี้, ความเร็วจะยังคงถูกจำกัด 500 mm/sในหน่วยประมวลผล
●สร้างแต่ละโปรแกรมโดยแยกไฟล์ออกจากกันและบังคับโปรแกรมให้มี 3000 เส้นของโค้ดแต่ละโปรแกรมเป็นส่วนใหญ่ โปรแกรมใหญ่จะถูกแบ่งให้เล็กลงและจะถูกเรียกตามลำดับ
ในส่วนก่อนหน้านี้แสดงวิธีการเปิดหน่วยประมวลผลที่แก้ไขอยู่:
1.เลือกโปรแกรม➔เพิ่ม/แก้ไขหน่วยประมวลผล
2.เลือก KUKA_KRC4
3.เลือก OK. หน่วยประมวลผลจะถูกแสดงในตัวแก้ไข Python IDLE
ตามส่วนดังต่อไปนี้แสดงว่าการเปลี่ยนแปลงจากคำแนะนำบนตัวแก้ไขอักษร
สร้างหนึ่งโปรแกรมต่อหนึ่งไฟล์
เพิ่มการเปลี่ยนแปลงดังต่อไปนี้เพื่อหลีกเลี่ยงการเพิ่มมากกว่าหนึ่งโปรแกรมต่อหนึ่งไฟล์และสร้างโปรแกรมด้วย 3000 เส้นของโค้ดส่วนใหญ่:
1.ตั้งค่าตัวแปรเป็น MAX_LINES_X_PROG ถึง 3000
2.ตั้งค่าตัวแปรเป็น INCLUDE_SUB_PROGRAMS ถึง False
บังคับความเร็วจำกัด
ตามขั้นตอนเหล่านี้เพื่อตั้งค่าความเร็วอยู่ที่ 500 mm/s และหลีกเลี่ยงการตั้งค่าความเร็วที่สูงกว่านี้โดยใช้ RoboDK:
1.ตั้งคำจำกัดความฟังก์ชั่นsetSpeed (def setSpeed)
2.เพิ่มเส้นดังต่อไปนี้เพื่อสร้าง $VEL.CP ผลลัพธ์ซึ่งจะเปลี่ยนความเร็วเป็นm/s:
speed_mms = min(speed_mms, 500)
ตัวกรองที่กำหนดเองสำหรับเฟรม
ส่วนนี้แสดงวิธีปรับแต่งการกำหนดเฟรมของหน่วยประมวลผลที่มีอยู่ ตัวอย่างเช่น การกำหนดเฟรมแบบกำหนดเองสำหรับหุ่นยนต์ KUKA
คุณสามารถใช้หน่วยประมวลผลที่คอมไพล์ไว้แล้ว และเขียนใหม่เฉพาะฟังก์ชันที่จำเป็นได้อย่างง่ายดาย (เช่น setFrame, setTool หรือ setSpeed)
ในตัวอย่างนี้ สมมติว่าเราต้องการปรับแต่งวิธีการกำหนดเบสสำหรับตัวควบคุม KUKA ตัวอย่างเช่น หากคุณต้องการให้บรรทัดต่อไปนี้ถูกส่งออกเมื่อกำหนดเฟรม:
BASE_DATA[8] = {FRAME: X:2000, Y:0, Z:0, A:0, B:0, C:0}
BAS (#BASE,8)
คุณเพียงแค่ต้องสร้างไฟล์ใหม่ชื่อ KUKA_Custom_Post.py ในโฟลเดอร์ C:/RoboDK/Posts/ ด้วยโค้ดเพียงไม่กี่บรรทัดต่อไปนี้ ซึ่งใช้หน่วยประมวลผลมาตรฐาน KUKA_KRC2 และเขียนทับการกำหนดเฟรม (ฟังก์ชัน setFrame):
from KUKA_KRC2 import RobotPost as MainPost
class RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; BASE_DATA[8] = {FRAME: %s}' % (self.pose_2_str(pose)))
self.addline('BAS (#BASE,8)')
อย่างไรก็ตาม เราสามารถเพิ่มตัวกรองที่กำหนดเองตามเกณฑ์บางอย่างเพื่อแยกความแตกต่างระหว่างพฤติกรรมมาตรฐานกับการใช้งานที่กำหนดเองได้ ไฟล์หน่วยประมวลผลสามารถแก้ไขได้ดังนี้:
from KUKA_KRC2 import RobotPost as MainPost
class RobotPost(MainPost):
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
if frame_name == "Frame 4": # Enter any condition here
# Trigger the call to the default method (same as not overriding the function)
super(MainPost, self).setFrame(pose, frame_id, frame_name)
return
# Implement a custom setFrame
self.addline('; ---- Setting reference: %s ----' % frame_name)
self.addline('; BASE_DATA[8] = {FRAME: %s}' % (self.pose_2_str(pose)))
self.addline('BAS (#BASE,8)')
self.addline('; --------------------------')
เมื่อสร้างโปรแกรมสำหรับตัวควบคุม KUKA KRC มีหลายวิธีในการกำหนดระบบพิกัดหรือเฟรม คำจำกัดความของ setFrame ต่อไปนี้แสดงการใช้งานอีกแบบหนึ่งพร้อมตัวเลือกต่าง ๆ:
def setFrame(self, pose, frame_id, frame_name):
"""Change the robot reference frame"""
self.addline('; ---- Setting reference: %s ----' % frame_name)
# option 1: Build the kinematics based on the MACHINE_DEF array and the provided offset
#self.addline('$BASE = EK (MACHINE_DEF[2].ROOT, MACHINE_DEF[2].MECH_TYPE, { %s })' % self.pose_2_str(pose))
# option 2: Build the kinematics based on the EX_AX_DATA array and the provided offset
#self.addline('$BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN, { %s })' % self.pose_2_str(pose))
# Option 3: Build the kinematics based on the EX_AX_DATA array and the pre-defined offset
#self.addline('; Using external axes')
#self.addline('; $BASE=EK(EX_AX_DATA[1].ROOT,EX_AX_DATA[1].EX_KIN,EX_AX_DATA[1].OFFSET)')
#self.addline('; $ACT_EX_AX= %i' % (self.nAxes - 6))
# Option 4: Use the BAS(#ex_BASE) init function from the BAS.src file
#self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
#self.addline('BAS(#ex_BASE,%i)' % self.BASE_ID)
# Option 5: Use the BAS(#BASE) init function from the BAS.src file
self.addline('; BASE_DATA[%i] = {FRAME: %s}' % (self.BASE_ID, self.pose_2_str(pose)))
self.addline('BAS (#BASE,%i)' % self.BASE_ID)
# Option 6: Directly take the base from the BASE_DATA array (usually what the BAS(#BASE) does)
# self.addline('$BASE=BASE_DATA[%i]' % self.BASE_ID)
self.addline('; --------------------------')
บังคับให้เคลื่อนที่โดยใช้มุมข้อต่อ
ส่วนนี้แสดงวิธีปรับแต่งหน่วยประมวลผลที่มีอยู่ เพื่อบังคับให้การเคลื่อนที่ของข้อต่อใช้ค่าข้อต่อแทนที่จะใช้ค่าพิกัดคาร์ทีเซียน
ในตัวอย่างนี้ เราจะนำการเปลี่ยนแปลงนี้ไปใช้กับตัวควบคุมหุ่นยนต์ ABB IRC5
1.ค้นหาคู่มือการเขียนโปรแกรมของตัวควบคุมหุ่นยนต์ของคุณ ในตัวอย่างนี้เราจะใช้คู่มือการเขียนโปรแกรม ABB IRC5 RAPID
2.ค้นหาคำสั่งสำหรับการเคลื่อนที่ของข้อต่อ ในกรณีนี้ คำสั่งสำหรับการเคลื่อนที่ของข้อต่อแบบสัมบูรณ์ของ ABB คือ MoveAbsJ คำสั่งนี้ต้องการตัวแปร jointtarget ซึ่งกำหนดค่าข้อต่อ
3.เลือก Program→Add/Edit Post Processor แล้วเลือกหน่วยประมวลผลที่คุณกำลังใช้อยู่เพื่อแก้ไข หากคุณกำลังใช้หน่วยประมวลผลที่ปรับแต่งได้อยู่แล้ว หน่วยประมวลผลนั้นจะถูกเลือกเป็นค่าเริ่มต้น
4.ค้นหาฟังก์ชัน MoveJ ในหน่วยประมวลผล ฟังก์ชันนี้กำหนดวิธีที่หน่วยประมวลผลสร้างคำสั่งสำหรับการเคลื่อนที่ของข้อต่อ สำหรับการเคลื่อนที่แบบเส้นตรง RoboDK จะใช้ MoveL แทน ใช้ Python แก้ไขบรรทัดที่เพิ่มเข้าไปในไฟล์โปรแกรม เพื่อให้ระบุข้อมูลมุมข้อต่อ ดังภาพต่อไปนี้
5.สุดท้าย คุณอาจต้องปรับวิธีที่หน่วยประมวลผลแปลงมุมข้อต่อหรือพิกัดท่าทาง (pose) ให้เป็นข้อความ ฟังก์ชัน angles_2_str และ pose_2_str กำหนดวิธีการแปลงมุมข้อต่อและพิกัดท่าทางให้เป็นข้อความตามลำดับ
หน่วยประมวลผล RoboDK ส่วนใหญ่ใช้ข้อมูลข้อต่อสำหรับการเคลื่อนที่ของข้อต่อ และใช้พิกัดคาร์ทีเซียนสำหรับการเคลื่อนที่แบบเส้นตรง ขอแนะนำให้เริ่มต้นจุดแรกของลำดับการเคลื่อนที่แบบเส้นตรงด้วยการเคลื่อนที่ของข้อต่อโดยระบุพิกัดข้อต่อเสมอ วิธีนี้จะช่วยป้องกันไม่ให้โปรแกรมเริ่มต้นด้วยการกำหนดค่าหุ่นยนต์ที่ไม่ถูกต้องและไปถึงจุดเอกฐานหรือขีดจำกัดของข้อต่อ
ที่เก็บหน่วยความจำที่สามารถใช้งานได้
โดยเริ่มต้น, หน่วยประมวลผลต่อไปนี้สามารถใช้ได้ใน RoboDK:
●ABB_RAPID_IRC5: สำหรับหุ่นยนต์ควบคุม ABB IRC5
●ABB_RAPID_S4C: สำหรับหุ่นยนต์ควบคุม ABB S4C
●Adept_Vplus: สำหรับ Adept V+ ภาษาการเขียนโปรแกรม
●Allen_Bradley_Logix5000: สำหรับ Allen Bradley Logix5000 PCL
●Comau_C5G: สำหรับหุ่นยนต์ควบคุมComau C5G
●Denso_RC8: สำหรับหุ่นยนต์ควบคุม Denso RC8
●Dobot: สำหรับหุ่นยนต์การศึกษา Dobot
●Fanuc_R30iA: สำหรับหุ่นยนต์ควบคุม Fanuc R30iA และ R30iB
●Fanuc_R30iA_Arc: สำหรับFanuc Arc welding
●Fanuc_RJ3: สำหรับหุ่นยนต์ควบคุม Fanuc RJ3
●GCode_BnR: สำหรับหุ่นยนต์ควบคุม B&R
●GSK: สำหรับหุ่นยนต์ GSK
●HIWIN_HRSS: สำหรับหุ่นยนต์ HIWIN
●KAIRO: สำหรับหุ่นยนต์ควบคุม Keba Kairo
●KUKA_IIWA: สำหรับ KUKA IIWA sunrise programming in Java
●KUKA_KRC2: สำหรับหุ่นยนต์ควบคุม KUKA KRC2
●KUKA_KRC2_CamRob: สำหรับ KUKA CamRob milling option
●KUKA_KRC2_DAT: สำหรับหุ่นยนต์ควบคุม KUKA KRC2 รวมทั้งข้อมูลไฟล์ DAT
●KUKA_KRC4: สำหรับหุ่นยนต์ควบคุม KUKA KRC4
●KUKA_KRC4_Config: สำหรับหุ่นยนต์ควบคุมKUKA KRC4 ด้วยการกำหนดค่าข้อมูลในแต่ละเส้น
●KUKA_KRC4_DAT: สำหรับหุ่นยนต์ควบคุม KUKA KRC4 รวมทั้งข้อมูลไฟล์ DAT
●Kawasaki: Kawasaki AS
●Mecademic: สำหรับหุ่นยนต์ Mecademic Meca500
●Mitsubishi: สำหรับหุ่นยนต์ควบคุม Mitsubishi
●Nachi_AX_FD: สำหรับหุ่นยนต์ควบคุม Nachi AX and FD
●OTC: สำหรับหุ่นยนต์ควบคุม Daihen OTC ช
●Precise: สำหรับหุ่นยนต์ Precise Scara
●Siemens_Sinumerik: สำหรับ Siemens Sinumerik ROBX
●Staubli_VAL3: สำหรับหุ่นยนต์ Staubli VAL3 robot programs (CS8 controllers and later)
●Staubli_VAL3_InlineMove: to generate Staubli VAL3 programs with inline movement data
●Staubli_S6: สำหรับหุ่นยนต์ควบคุม Staubli S6
●Toshiba: สำหรับหุ่นยนต์ Toshiba
●Universal_Robots: สำหรับหุ่นยนต์ UR robots, สร้างการเคลื่อนที่เส้นตรงเหมือนกับเป้าหมายลวง
●Universal_Robots_RobotiQ: สำหรับหุ่นยนต์ UR รวมถึงสนับสนุนสำหรับตัวจับ RobotiQ
●Universal_Robots_joints: สำหรับหุ่นยนต์ UR robots,สร้างการเคลื่อนที่เส้นตรงซึ่งเป้าหมายร่วมกัน
●Yamaha: สำหรับหุ่นยนต์ Yamaha
แหล่งอ้างอิง
วิดีโอต่อไปนี้แสดงถึงภาพรวมของหน่วยประมวลผลใน RoboDK:
https://robodk.com/help#PostProcessor
เอกสารอ้างอิงสำหรับแต่ละวิธีในหน่วยประมวลผลสามารถดูออนไลน์ได้:
https://robodk.com/doc/en/PythonAPI/postprocessor.html
หน่วยประมวลผลทั้งหมดที่ใช้โมดูล robodk.py :
https://robodk.com/doc/PythonAPI/robodk.html#robodk.Mat
โมดูล robodk.pyจัดหาเครื่องมือสำหรับลักษณะการปฏิบัติการ (การเพิ่มจำนวน, การผกผัน, …) และการแปลงระหว่างลักษณะของมุมออยเลอร์ในรูปแบบที่แตกต่างกัน,ท่ามกลางหลายอย่าง
หนังสืออ้างอิงสามารถดูออนไลน์เพื่อเรียนรู้เกี่ยวกับการเขียนโปรแกรม Python
https://docs.python.org/3/
เมื่อโปรแกรมได้ถูกสร้างขึ้นแล้ว, กระบวนการก่อนหน้า/เป็นสากล ของโปรแกรม Python ถูกสร้างขึ้นและบันทึกถาวรในพื้นที่โฟลเดอร์ โปรแกรมกระบวนการก่อนหน้าถูกเชื่อมต่อกกับหน่วยประมวลผลที่ถูกต้อง (ถูกเลือกจากผู้ใช้ใน RoboDK) หน่วยประมวลผลกำหนดระดับตำแหน่งหุ่นยนต์ซึ่งสร้างขึ้นตามโค้ดที่อยากเขียน
โปรแกรมก่อนการรวบรวมและดำเนินการกับPython
