1. Đầu đề thiết kế
Lập trình mô phỏng hoạt động cuả rôbốt Scara 4 bậc tự do.
2 .Các số liệu ban đầu
3 .Nội dung thuyết minh và tính toán
Đồ án gồm các phần chính sau:
A. Mục đích của đồ án tin học ứng dụng
Tìm hiểu
- Tìm hiểu về 1 robot cụ thể sử dụng trong công nghiệp(Robot Scara)
- Tìm hiểu về các cơ cấu hoạt động của Robot - các khâu hoạt động của
Rôbốt.
- Tìm hiểu về động học và mô hình 3D của Robot mô phỏng hoạt động của
Robot
- Tìm hiểu cách xây dựng chương trình điều khiển cho robot
B. Nhiệm vụ của em trong đồ án tin học ứng dụng là xây dựng chương trình mô
phỏng hoạt động của robotScara 4 bậc tự do.
+ Các công cụ để xây dựng bài toán mô phỏng
- Ngôn ngữ lập trình C++(Xây dựng giao diện MFC,xây dựng chương trình dọc file
dữ liệu có dạng .*BDF và .*STL).
- Lập trình đồ họa OPEN GL để xây dựng các khối đồ họa để mô phỏng (Tìm hiểu
kỹ các gói thư viện của OPEN GL).
- Các công cụ cần để xây dựng là Visual C++ 6.0 (tạo Project với Visual C++)
C. Kết quả đạt được qua đồ án
- Hiểu đuợc nguyên lý hoạt động của Robot trong công nghiệp qua chương trình
mô phỏng
- Có 1 chương trình cụ thể để mô phỏng .
- Tìm hiểu và lập trình MÔ PHỎNG với openGL.
- Tìm hiểu về phần mền lập trình Visual C++ 6.0.
- Tìm hiểu về ngôn ngữ lập trình VC++
MỤC LỤC
MỤC LỤC . . 4
LỜI NÓI ĐẦU
.9
GIỚI THIỆU TỔNG QUAN VỀ ROBOT CÔNG NGHỆP VÀ MÔ PHỎNG
HOẠT ĐỘNG
.11
CHƯƠNG I: CÁC C NG C ĐỂ XÂY DỰNG BÀI TOÁN PHỎNG HOẠT
ĐỘNG CỦA ROBOT . . 13
1.1. Giới thiệu về Open GL
13
1.1.1.Đ c điểm của OpenGL
.14
1.1.2. Các thư viện hỗ trợ lập trình
OpenGL 20
1.1.3. Các bước tổng quan khi xây dựng ứng dụng đồ họa với
OpenGL .21
1.1.4. Xây dựng các đối tượng 3 chiều
23
1.1.5. Quan sát các đối tượng 3 chiều
24
1.2.Giới thiệu về VisualC++ và ứng dụng
MFC .27
1.3. Tìm hiểu phần mềm thiết kế VS 6.0 và AutoCAD ,
SolidWorks .28
CHƯƠNG II: CÁC BƯỚC XÂY DỰNG BÀI TOÁN PHỎNG 32
2.1. Cách tạo ra một project MFC để mô phỏn 32
2.2. Khởi tạo và thiết lập các gói thư viOpenGL .39
2.3. Thiết kế mô hình Robot trên SolidWork
2007 .58
2.4. Xây dựng module đọc file .*STL và
.*BDF 61
2.4.1. Xây dựng module đọc file .*STL
61
2.4.2 Xây dựng module đọc file .*BDF
65
2.5. Mô phỏng chương trình trên OpenGL
74
CHƯƠNG III: CHẠY CHƯƠNG TRÌNH PHỎNG . 75
KẾT LUẬN . . 81
Tài liệu tham khảo . . 83
86 trang |
Chia sẻ: lvcdongnoi | Lượt xem: 4020 | Lượt tải: 1
Bạn đang xem trước 20 trang tài liệu Đồ án Lập trình mô phỏng hoạt động của rô bốt Scara 4 bậc tự do, để xem tài liệu hoàn chỉnh bạn click vào nút DOWNLOAD ở trên
một phần mềm nhỏ hỗ trợ thiết kế
chuyên dùng nhƣ AutoCAD hay SolidWork, 3D Max..
- Sử dụng các lệnh trong các phần mềm đó để xuất đối tƣợng 3 chiều ra các
dạng tập tin nh phân hay ASCII (American Standard Code for Information
Interchange) có chứa các thông tin của đối tƣợng dƣới dạng các đ nh và quy t c nối
các đ nh đó thành đa giác. Ví dụ các tập tin *.BDF, *.SLT,*.NVT
- Đọc thông tin các đối tƣợng từ các tập tin đó và sử dụng các hàm vẽ đối
tƣợng cơ bản của OpenGL xây dựng lại đối tƣợng 3 chiều cơ bản ban đầu.
Vì vậy đây chính là cơ sở cho để xây dựng các bài toán mô phỏng hoạt động của
ROBOT.
Hình 1.10: Các dối tượng 3D được xây dựng lại trên OpenGL.
______________________________________________________________________________________
31
ĐỒ ÁN TỐT NGHIỆP
Hình 1.11: Quá trình Render màu sắc của vật liệu
2.3 .Quan sát các đối tượng 3 chiều
Quan sát các đối tƣợng là một khái niệm cho ph p các đối tƣợng hình học 3 chiều
hiển th lên màn hình máy tính (hai chiều ) với hiệu ứng không gian ba chiều. Quan
sát đối tƣợng gồm các thao tác: Xác đinh v trí quan sát, hƣớng quan sát, phạm vi
quan sát, xác đ nh v trí các đối tƣợng trong không gian ba chiều, chọn các ph p
chiếu, chọn khung nhìn vv.
Quá trình chuyển các đối tƣợng ba chiều trong không gian ba chiều thành các điểm
ảnh trên màn hình máy tính có thể chia làm các bƣớc:
______________________________________________________________________________________
32
ĐỒ ÁN TỐT NGHIỆP
+ Các ph p biến đổi: biến đổi v trí quan sát hay v trí của vật quan sát. Vì OpenGL
xây dựng vật thể trên mô hình không gian 3 chiều nên các ph p biến đổi sẽ đƣợc
thực hiện thông qua việc thực hiện các ph p toán trên ma trận. Quá trình thực hiện
biến đổi sẽ diễn ra nhƣ sau: Sau khi ta khai báo vật thể thông qua các vertex, ta đã
có đƣợc các điểm trong không gian 3 chiều với tọa độ dƣới dạng vector 4 phần tử.
Để thực hiện di chuyển, quay, phối cảnh,.. ta cần áp vào các thông số nhƣ góc
quay, độ di dời... tƣơng ứng với thay đổi muốn thực hiện. OpenGL sẽ dùng các
thông số biến đổi mà ta nhập vào (đƣợc lƣu trữ dƣới dạng ma trận 4x4) và thực
hiện các ph p toán biến đổi trên các vector nhập vào. Kết quả là tọa độ các vertex
mà chúng ta đã nhập sẽ thay đổi tƣơng ứng.
Để chọn ma trận nào sẽ đƣợc thay đổi (muốn thực hiện ph p biến đổi nào), ta dùng
hàm :
void glMatrixMode(GLenum mode)
Mode có thể là:
GL_MODELVIEW Các ph p toán ma trận sau đó sẽ tác
động lên ma trận modelview
GL_PROJECTION Các ph p toán ma trận sau đó sẽ tác
động lên ma trận projection
GL_TEXTURE Các ph p toán ma trận sau đó sẽ tác
động lên ma trận texture
Sau khi gọi hàm này và đƣa tham số tƣơng ứng, ma trận đƣợc chọn sẽ trở thành ma
trận biến đổi hiện hành và mọi hàm biến đổi tƣơng ứng sẽ tác động lên ma trận đó.
Để đƣa một ma trận biến đổi hiện hành về ma trận đơn v , dùng hàm:
void glLoadIdentity(void)
Để đƣa giá tr mới vào cho ma trận biến đổi hiện hành, dùng hàm:
void glLoadMatrix*()
Để áp các phép biến đổi trực tiếp khỏi gọi hàm thì ta cung cấp một ma trận và gọi
glMulMatrix*() với tham số là ma trận biến đổi. Hàm này sẽ nhân ma trận tham số
vào ma trận biến đổi hiện hành (ví dụ ma trận tham số là và ma trận biến đổi
______________________________________________________________________________________
33
ĐỒ ÁN TỐT NGHIỆP
hiện hành là C thì sau khi nhân, kết quả ma trận hiện hành là C ). Chú ý: khi lập
trình OpenG trong C, khi khai báo ma trận 4x4 để thực hiện thay đổi ma trận
biến đổi hiện hành thì M[i][j] chỉ vị trí phần tử cột i hàng j, khác với quan niệm
thông thƣờng trong C là hàng i cột j, để tránh nhầm lẫn, tốt nhất là khai báo mảng
16 phần tử
+ Chọn các ph p chiếu: trực giao hay phối cảnh.
- Ph p chiếu trực giao :
Vật thể ở gần ống kính (ở đây là điểm nhìn) thì thấy lớn và ngƣợc lại. OpenGL cho
ta một hàm để xác đ nh không gian nhìn.
void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
GLdouble near, GLdouble far);
- Ph p chiếu phối cảnh:
Các đƣờng thẳng song song trong không gian thì khi thể hiện lên màn hình cũng sẽ
song song. Nói cách khác, không gian nhìn đƣợc xác đ nh bởi một hình hộp chữ
nhật. Để thiết lập chế độ quan sát này, ta dùng hàm
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom,GLdouble top,
GLdouble near, GLdouble far);
Hình 1.12: Phép chiếu trực giao
______________________________________________________________________________________
34
ĐỒ ÁN TỐT NGHIỆP
Các tham số có ý ngh a tƣơng tự nhƣ hàm glFrustum().
Khi ch cần chiếu hình 2 chiều, có thể gọi void glOrtho2D(). Hàm này ch nhận 4
tham số đầu có ý ngh a giống glOrtho(), nhƣng khối hộp không gian nhìn có giá tr
z dao động trong đoạn [-1.0,1.0]. Tuy nhiên, vì là hình 2 chiều nên giá tr z luôn
b ng 0 và do đó không b mất hình.
+ Chọn khung nhìn: (Viewport)
Viewport là một khung hình chữ nhật trong cửa sổ chƣơng trình vẽ. Nó là nơi mà
vật thể sẽ đƣợc vẽ vào (có thể có kích thƣớc nhỏ hơn, b ng ho c lớn hơn kích
thƣớc cửa sổ chƣơng trình). Hàm void glViewport(GLint x, GLint y, GLsizei
width, GLsizei height) xác đ nh một khung nhìn có tọa độ góc trái dƣới là (x,y) so
với góc trái dƣới của cửa sổ và đƣợc tính b ng pixel; width và height xác đ nh kích
thƣớc của khung nhìn. M c đ nh, viewport có kích thƣớc b ng kich thƣớc cửa sổ.
Tỷ lệ giữa chiều dài và chiều rộng của viewport nên b ng với t lệ tƣơng ứng trong
không gian nhìn mà ta đã xác đ nh thông qua các hàm glFrustum() ho c glOrtho(),
nếu không hình ảnh sẽ b biến dạng
Hình 1.13: Phép chiếu phối cảnh
______________________________________________________________________________________
35
ĐỒ ÁN TỐT NGHIỆP
+ Sự biến đổi v trí quan sát và v trí vật thể.
Do sự biến đổi v trí quan sát và v trí vật thể có liên quan tƣơng đối với nhau nên
trong OpenGL chúng đƣợc gom vào một ma trận biến đổi (ch dành cho vật thể).
M c đ nh ban đầu là điểm nhìn và vật thể ở chung một chỗ tại gốc hệ trục tọa độ và
phƣơng nhìn theo hƣớng âm của trục z (hƣớng vào bean trong màn hình).
OpenGL cung cấp 3 hàm để thay đổi góc nhìn và hƣớng nhìn: glTranslate*() (di
chuyển), glRotate*() (quay), glScale*() (dùng để k o dãn ho c co nhỏ vật thể). Các
hàm này tác động lên tọa độ vật thể.
Các thành phần của hàm glTranslate():
void glTranslate{fd} (TYPE x, TYPE y, TYPE z): dời vật thể đi một đoạn x, y,
và z theo phương các trục tọa độ tương ứng.
Các thành phần của hàm glRotate() :
void glRotate{fd}(TYPE angle, TYPE x, TYPE y, TYPE z): quay vật thể 1 góc
angle độ theo chiều ngược chiều kim đồng hồ quanh trục có vector chỉ phương
xác định từ gốc trục toạ độ (0,0,0) và điểm (x,y,z).Ví dụ:
glRatated(45,0,0,1);
Các thành phần của hàm glScale():
void glScale{fd}(TYPEx, TYPE y, TYPEz): co dãn vật thể theo các phương Ox,
Oy, Oz một lượng tương ứng. Nếu x hoặc y hoặc z âm thì vật thể sẽ bị lật lại
đối xứng theo trục có độ giãn âm.Ví dụ: glScalef(2.0,-0.5,1.0);
Hình 1.14: Hệ tọa dộ chuẩn trongOPENGL
______________________________________________________________________________________
36
ĐỒ ÁN TỐT NGHIỆP
Hình 1.15: Các phép biến đổi trong OpenGL
- Tạo chuyển động cho các đối tƣợng.
Nguyên t c chung để tạo các hình ảnhchuyển động là vẽ và xoá liên tục các v
trí khác nhau của đối tƣợng chuyển động. Việc phân tích, tính toán v trí các
vật r n thuộc cơ hệ phải đƣợc thực hiện trƣớc khi mô phỏng. Quá trình mô
phỏng thực hiện vẽ các v trí đã đƣợc tính toán trƣớc. Không nên thực hiện
song song vừa vẽ, vừa tính toán đối với các chuyển động đòi hỏi tính toán
phức tạp ho c cấu hình máy tính không đủ cao. Chuyển động của các vật r n
đƣợc cập nhập theo thời gian vì vậy việc tính toán các v trí cũng phải đƣợc
cập nhập theo thời gian.
Theo lý thuyết hệ nhiều vật, v trí của một vật r n trong m t phẳng ho c trong
không gian có thể xác đ nh b ng các ma trận côsin ch phƣơng so với hệ toạ
độ cố đ nh. Trong OpenGL v trí của đối tƣợng cũng đƣợc thay đổi b ng ph p
nhân các toạ độ của đối tƣợng với ma trận hiện hành. Giá tr của các ma trận
hiện hành đƣợc biến đổi b ng các ph p biến hình nhƣ : t nh tiến, quay.
3. Giới thiệu về ngôn ngữ lập trình Visual C++ và các ứng dụng của FC.
______________________________________________________________________________________
37
ĐỒ ÁN TỐT NGHIỆP
Visual C
++
là một trong các ngôn ngữ lập trình thuộc dòng Visual Studio của
hãng Microsoft, phát triển dựa trên nền tảng là ngôn ngữ lập trình hƣớng đối tƣợng
C
++
. Visual C
++
ra đời khoảng những năm 1990 và càng ngày càng đƣợc sử dụng
rộng rãi nhất là các ứng dụng trong kỹ thuật nhƣ là lập trình nhúng,lập trình điều
khiển và lập trình mô phỏng. Việc tạo ra các giao diện phức tạp và trình bày đẹp
đối với Visual C++ khá là đơn giản, và đây chính là thế mạnh của Visual C++ trong
việc trợ giúp đ c lực cho ngƣời lập trình khi xây dựng những dự án lớn ho c trong
kỹ thuật lập trình hệ thống.
MFC là lớp nền tảng của Microsoft (Microsoft Foundation Classes), là một
công cụ mạnh trong lập trình ứng dụng cho hầu hết các l nh vực vì nó có giao diện
đáp ứng mọi nhu cầu của ngƣời sử dụng trong việc thiết kế các giao diện của
chƣơng trình mô phỏng.
______________________________________________________________________________________
38
ĐỒ ÁN TỐT NGHIỆP
CHƢƠNG 2
XÂY DỰNG CHƢƠNG TRÌNH PHỎNG
Các bƣớc xây dựng bài toán mô phỏng gồm có:
- Cách tạo ra project MFC để thực hiện quá trình mô phỏng.
- Khởi tạo các gói thƣ viện của OpenGL.
- Thiết kế mô hình trên Solidworks.
- Chuyển mô hình sang tệp tin *.STL.
- Xây dựng Module đọc File *.STL.
- Xây dựng Module đọc File quỹ đạo đã số hóa trên AutoCAD.
- Chạy file quỹ đạo đã số hóa trên AutoCAD.
- Mô phỏng trên OpenGL.
2.1 Cách tạo ra một Project FC để mô phỏng hoạt động
+ Nhƣ chƣơng 1 em đã trình bày về phần mềm Visual 6.0 bây giờ ta tạo 1 Project
MFC nhƣ sau :
- Chọn File -> New sau đó chọn Tab Projects và sẽ hiện ra các Project đƣợc lập
trình trên Visual C++ 6.0.Ở đây ta chọn loại MFC AppWizard(exe).Trong Project
name ta g tên của dự án ở đây là “DoanTinhoc” nhƣ hình vẽ
______________________________________________________________________________________
39
ĐỒ ÁN TỐT NGHIỆP
Hình 2.1 : Bắt đầu thiết lập project MFC
Các bƣớc tiếp theo để thiết lập project nhƣ sau :
Bước 1 : Chọn Single Document Interface : đây là loại giao diên đơn tài liệu tại
một thời điểm, ch có 1 tài liệu đƣợc mở và hiện hành, để cho ngƣời dùng thao tác
trên nó.Trong đồ án tin học này chủ yếu là mô phỏng hoạt động của Rôbốt nên ta
sử dụng kiểu đơn tài liệu.
______________________________________________________________________________________
40
ĐỒ ÁN TỐT NGHIỆP
Hình 2.2 : Thiết lập 1
Bước 2 : Ta chọn nhƣ hình vẽ ở dƣới và do ứng dụng không sử lý Dữ liệu nên ở
Database Support ta chọn None.
______________________________________________________________________________________
41
ĐỒ ÁN TỐT NGHIỆP
Hình 2.3 : Thiết lập 2
Bước 3 : Ta chọn nhƣ hình vẽ dƣới đây - Chọn None vì trong ứng dụng không sử
dụng tài liệu phức hợp.
Hình 2.3 : Thiết lập 2
H 2.4 : T ế 3
Bước 4 : Đến bƣớc số 4 ta chọn các thiết lập sau :
- Docking Toolbar : Yes - Chọn thanh công cụ có g n vào cửa sổ .
- Initial Status Bar : Yes - Chọn thanh trạng thái có g n vào ứng dụng
- Printing and Printer Preview : No – Không in ấn gì
- 3D controls : Yes – Có điều khiển nổi
______________________________________________________________________________________
42
ĐỒ ÁN TỐT NGHIỆP
- Toolbars look : Normal – Dạng thanh công cụ bình thƣờng.
Hình 2.3 : Thiết lập 4
Bước 5 : Chọn các thiết lập nhƣ sau :
- MFC Standard : dạng chuẩn của MFC
- MFC Library : As a shared DLL – Thƣ viện của MFC – có chia sẻ thƣ viện
liên kết động.
______________________________________________________________________________________
43
ĐỒ ÁN TỐT NGHIỆP
Hình 2.6 : Thiết lập 5
Bước 6 : Finish – Hoàn tất việc thiết lập.
______________________________________________________________________________________
44
ĐỒ ÁN TỐT NGHIỆP
Hình 2.7 : Hoàn thành thiết lập Project MFC
Sau khi khởi tạo xong ta chạy thử chƣơng trình thì thu đƣợc giao diện của 1 project
MFC cơ bản nhƣ hình vẽ dƣới đây.
______________________________________________________________________________________
45
ĐỒ ÁN TỐT NGHIỆP
Hình 2.8 : Chạy thử Project MFC
Nhƣ vậy có thể thấy r MFC đã làm gì cho ta .M c dù chƣa xây dựng code chƣơng
trình nhƣng MFC đã cung cấp sẵn giao diện của một ứng dụng chuẩn trong môi
trƣờng Windows.Mà Visual C++ là một ngôn ngữ lập trình hƣớng đối tƣợng, cho
nên mọi ứng dụng đều đƣợc xây dựng trên cơ sở của các lớp.Khi một ứng dụng
đƣợc tạo ra nó có các lớp cơ sở sau :
Hình 2.9 : Các lớp ứng dụng trong MFC
Chức năng của các lớp cơ sở của ứng dụng MFC nhƣ sau :
- CApp : là lớp ứng dụng (Applicatiton Class) có nhiệm vụ là khởi tạo và chạy ứng
dụng.
- CDoc : là lớp tài liệu (Document Class) của ứng dụng, có nhiệm vụ nạp và duy trì
1 tài liệu. Một tài liệu có thể là bất cứ cái gì,từ một bản thảo cho đến các việc cài
đ t của một thiết b mạng Tuy nhiên, mục đích sử dụng của chƣơng trình là mô
phỏng nên không cần quan tâm nhiều đến lớp này.
______________________________________________________________________________________
46
ĐỒ ÁN TỐT NGHIỆP
- CView: là lớp hiển th của ứng dụng (View Class),có nhiệm vụ cung cấp một hay
nhiều View (khung) cho tài liệu.Trong chƣơng trình mô phỏng ta sẽ cần sử dụng
rất nhiều trong lớp này để khởi tạo cho OpenGL và các thao tác vẽ lại trên lớp này.
- CmainFrame: là lớp khung (Frame Class) của ứng dụng và có nhiệm vụ hiển th
và truyền lệnh của ngƣời dùng.
2.2- Khởi tạo và Thiết lập các gói thƣ viện của OpenGL
Mục đích chính của chƣơng trình là mô phỏng quá trình hoạt động của Robot, vì
vậy cần thiết phải có một môi trƣờng đồ họa.Khi mới tạo ra một dự án MFC thì
ứng dụng ch cung cấp cho ta khung giao diện chuẩn dạng cửa sổ,và môi trƣờng
làm việc chủ yếu là thao tác với CSDL.Do đó chúng ta cần phải tiến hành khởi tạo
một môi trƣờng đồ họa, cụ thể trong đồ án này em dùng OpenGL. Cũng giốn nhƣ
GDI cần một ngữ cảnh thiết b (Device Context – DC )để vẽ, OpenGL cũng cần có
một ngữ cảnh biểu diễn (Rendering Context – RC) .Tuy nhiên, không giống nhƣ
GDI là mỗi lệnh GDI yêu cầu một DC để vẽ, thì OpenGL lại dùng khái niệm một
RC hiện hành. Khi một ngữ cảnh biểu diễn đƣợc hiện hành trong một thread
(luồng), mọi lời gọi OpenGL trong thread sẽ sử dụng cùng một ngữ cảnh biểu diễn
hiện hành.Trong khi rất nhiều ngữ cảnh biểu diễn có thể, đƣợc sử dụng để vẽ vào
trong một cửa sổ đơn, thì ch có một ngữ cảnh duy nhất đƣợc hiện hành tại một
thời điểm trong thread đơn.
Để tạo ra và hiện hành một ngữ cảnh biểu diễn OpenGL có 3 bƣớc cơ bản nhƣ sau :
Bước 1 : Ta phải đ nh dạng điểm ảnh .
Bước 2 : Ta phải tạo ngữ cảnh biểu diễn .
Bước 3 : Làm cho ngữ cảnh biểu diễn hiện hành.
______________________________________________________________________________________
47
ĐỒ ÁN TỐT NGHIỆP
Qua 6 bƣớc cơ bản trên ta đã tạo ra đƣợc 1 Project MFC, để mô phỏng đƣợc các
hoạt động của Rôbốt thì ta phải thiết lập môi trƣờng đồ họa.
Hình 2.10 : Thiết lập các gói thư viện OpenGL
Để tạo đƣợc ngữ cảnh biểu diễn của OpenGL thì trƣớc tiên ta phải include(bao
gồm) tất cả các tập thƣ viện của OpenGL vào trong Project này. Từ thanh Menu
chính của chƣơng trình Visual C++ 6.0 ta chọn Project -> Settings sau đó chọn Tab
là Link , chọn category là “General” và nhập vào hộp thoại Object/library modules
là : “opengl32.lib glu32.lib glaux.lib” nhƣ hình vẽ trên và chọn nút OK.
Sau đó ta mở tệp “stdafx.h” ra và thêm vào các dòng code sau :
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#include // MFC core and standard components
#include // MFC extensions
//------------------------------------------------------------------------
// Các đọa mã thêm vào ở đây .
#include //OpenGL Main Library Header
#include //OpenGL Utility Library Header
#include
//-----------------------------------------------------------------------
______________________________________________________________________________________
48
ĐỒ ÁN TỐT NGHIỆP
#include // MFC Automation classes
#include // MFC support for Internet Explorer 4 Common
Controls
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT
Open GL yêu cầu cửa sổ phải có kiểu WS_CLIPCHILDREN và
WS_CLIPSIBLINGS vì vậy cần phải thêm vào hàm
PreCreateWindow(CREATESTRUCT& cs) của lớp CDoanTinhocView nhƣ sau :
BOOL CDoanTinhocView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
cs.style |= (WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
return CView::PreCreateWindow(cs);
}
Bây giờ chúng ta sẽ thực hiện bƣớc thứ nhất, tạo đ nh dạng điểm ảnh.Đ nh dạng
điểm ảnh sẽ miêu tả cách lƣu trữ trong bộ nhớ các phần tử đồ họa mà Windows
hiển th .Thông số đƣợc điều khiển bởi đ nh dạng điểm ảnh bao gồm độ sâu màu,
phƣơng pháp bộ đệm và giao diện đồ họa đƣợc hỗ trợ. Đầu tiên tạo một protected
member function trong lớp CDoanTinhocView có tên là BOOL
CDoanTinhocView::SetWindowPixelFormat(HDC hDC) có nội dung nhƣ sau :
//------------------------------------------- Code here ----------------------
--------//
BOOL CDoanTinhocView::SetWindowPixelFormat(HDC hDC)
{
PIXELFORMATDESCRIPTOR pixelDesc;
pixelDesc.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pixelDesc.nVersion = 1;
pixelDesc.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER;
pixelDesc.iPixelType = PFD_TYPE_RGBA;
pixelDesc.cColorBits = 32;
pixelDesc.cRedBits = 0;
pixelDesc.cRedShift = 0;
pixelDesc.cGreenBits = 0;
pixelDesc.cGreenShift = 0;
pixelDesc.cBlueBits=0;
pixelDesc.cBlueShift=0;
pixelDesc.cAlphaBits=0;
pixelDesc.cAlphaShift=0;
pixelDesc.cAccumBits=0;
pixelDesc.cAccumRedBits=0;
pixelDesc.cAccumGreenBits=0;
pixelDesc.cAccumBlueBits=0;
pixelDesc.cAccumAlphaBits=0;
______________________________________________________________________________________
49
ĐỒ ÁN TỐT NGHIỆP
pixelDesc.cDepthBits=32;
pixelDesc.cStencilBits=0;
pixelDesc.cAuxBuffers=0;
pixelDesc.iLayerType= PFD_MAIN_PLANE;
pixelDesc.bReserved=0;
pixelDesc.dwLayerMask=0;
pixelDesc.dwVisibleMask=0;
pixelDesc.dwDamageMask=0;
m_GLPixelIndex = ChoosePixelFormat( hDC,&pixelDesc);
if (m_GLPixelIndex==0)
{
m_GLPixelIndex = 1;
if(DescribePixelFormat(hDC,m_GLPixelIndex,sizeof(PIXELFORMATDESCRIPTOR),
&pixelDesc)==0)
{
return FALSE;
}
}
if (SetPixelFormat( hDC,m_GLPixelIndex,&pixelDesc)==FALSE)
{
return FALSE;
}
return TRUE;
// glCullFace(GL_BACK);
}
Tiếp theo chúng ta thêm vào protected member variable trong lớp
CDoanTinhocView:
int m_GLPixelIndex; // protected variable
Sau đó, mở ClassWizard, thêm vào hàm OnCreate đáp ứng thông báo
VM_CREATE nhƣ sau:
______________________________________________________________________________________
50
ĐỒ ÁN TỐT NGHIỆP
Hình 2.11 : Chọn hàm Oncreate() để thiết lập OpenGL
Sau khi các đ nh dạng điểm đƣợc thiết lập, tất cả những gì chúng ta cần làm bây
giờ là tạo ra một ngữ cảnh biểu diễn và làm cho nó hiện hành. B t đầu thêm vào
một protected member function vào lớp CDoanTinhocView có tên là :
//----------------------------------------------------------------------//
BOOL CDoanTinhocView::CreateViewGLContext(HDC hDC)
{
m_hGLContext= wglCreateContext(hDC);
if(m_hGLContext == NULL)
return FALSE;
if (wglMakeCurrent(hDC,m_hGLContext)== FALSE)
return FALSE;
return TRUE;
}
//------------------------------------------------------------------------//
và ta thêm biến thành viên protected member variable vào trong lớp
CDoanTinhocView nhƣ sau :
protected:
HGLRC m_hGLContext;
______________________________________________________________________________________
51
ĐỒ ÁN TỐT NGHIỆP
Và sau đó sửa lại mã lệnh trong hàm OnCreate nhƣ sau :
int CDoanTinhocView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CView::OnCreate(lpCreateStruct) == -1)
return -1;
// TODO: Add your specialized creation code here
HWND hWnd = GetSafeHwnd();
HDC hDC = ::GetDC(hWnd);
if (SetWindowPixelFormat(hDC)==FALSE)
return 0;
// new code
if(CreateViewGLContext(hDC) == FALSE)
return 0;
//
return 0;
}
Tiếp theo ta thêm vào hàm OnDestroy đáp ứng thông báo WM_DESTROY để hủy
bỏ ngữ cảnh biểu diễn khi chƣơng trình kết thúc nhƣ sau :
Hình 2.12 : Chọn hàm OnDestroy() để hủy OpenGL
Và mã lệnh của nó nhƣ sau :
______________________________________________________________________________________
52
ĐỒ ÁN TỐT NGHIỆP
//------------------------------------------------------------------------//
void CDoanTinhocView::OnDestroy()
{
if(wglGetCurrentContext()!=NULL)
wglMakeCurrent(NULL,NULL);
if( m_hGLContext!=NULL)
{
wglDeleteContext(m_hGLContext);
m_hGLContext=NULL;
}
CView::OnDestroy();
}
//----------------------------------------------------------------------------
--//
Sau đó ta ch nh lại mã lệnh của cấu tử CDoanTinhocView() nhƣ sau :
CDoanTinhocView::CDoanTinhocView()
{ // TODO: add construction code here
m_hGLContext = NULL;
m_GLPixelIndex = 0;
}
Nhƣ vậy ta đã tiến hành xong quá trình khởi tạo, tại ra môi trƣờng đồ họa để có thể
thực hiện các thao tác mô phỏng.Bƣớc tiếp theo,chúng ta sẽ tìm hiểu làm thế nào
để thực hiện đƣợc một chƣơng trình mô phỏng đơn giản.Sau khi thực hiện các thao
tác trên thì nếu chạy chuơng trình thì v n chƣa có gì, m c dù OpenGL đã đƣợc
khởi tạo.Đó là do chúng ta chƣa tạo ra Viewport và thiết lập các Matrix Mode.Để
thực hiện điều này, ta sử dụng ClassWizard, thêm vào hàm OnSize, đáp ứng thông
báo WM_SIZE
______________________________________________________________________________________
53
ĐỒ ÁN TỐT NGHIỆP
Hình 2.13 : Chọn hàm OnSize() để thiết lập các ứng dụng OpenGL
và sửa lại mã lệnh nhƣ sau :
//----------------------------------------------------------------------------
-//
void CDoanTinhocView::OnSize(UINT nType, int cx, int cy)
{
CView::OnSize(nType, cx, cy);
GLsizei width,height;
GLdouble aspect;
width = cx;
height =cy;
if (cy==0)
aspect=(GLdouble)width;
else
aspect=(GLdouble)width/(GLdouble)height;
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,aspect,1.0f,1000.0f); // Phep chieu truc giao phoi canh
// gluOrtho2D(0.0,500.0*aspect,0.0,500.0);
glMatrixMode(GL_MODELVIEW); // Ma tran chieu de mo phong hoat dong cua ROBOT
glLoadIdentity();
glEnable(GL_DEPTH_TEST); // Enable Depth Testing
}
//----------------------------------------------------------------------------
-------//
______________________________________________________________________________________
54
ĐỒ ÁN TỐT NGHIỆP
Hàm glViewport (0,0,width,height) tạo ra một khung nhìn hình chữ nhật có tạo độ
đ nh trái dƣới là (0,0) và tọa độ của đ nh phải trên là (width,height).Hàm
glMatrixMode(GL_PROJECTION) chọn kiểu ma trận là GL_PROJECTION(ma
trận chiếu). Sau đó glLoadIndentity() nạp lại ma trận đơn v m c đ nh cho ma trận
hiện hành (ma trận chiếu vừa đƣợc chọn bởi hàm
glMatrixMode(GL_PROJECTION)). Hàm gluOrtho2D đ nh ngh a một ma trận
chiếu ph p chiếu trực giao 2D, với kích thƣớc là các tham số truyền vào.Tƣơng tự,
hai hàm còn lại là chọn và thiết lập cho ma trận quan sát mô hình.
Sau đó lại sử dụng ClassWizard thêm vào hàm OnPaint đáp ứng lại thông báo
WM_PAINT nhƣ sau :
Hình 2.14 : Chọn hàm OnPaint() để vẽ các đối tượng OpenGL
______________________________________________________________________________________
55
ĐỒ ÁN TỐT NGHIỆP
Và mã lệnh nhƣ sau :
//----------------------------------------------------------------------------
-------//
void CDoanTinhocView::OnPaint()
{
CPaintDC dc(this); // device context for painting
//----------------------------------------------------------------------------
---//
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glTranslatef(0.0f,0.0f,-6.0f);
glRotatef(-45.0f,0.0f,1.0f,0.0f);
glRotatef(30.0f,1.0f,0.0f,-1.0f);
glBegin(GL_QUADS);
// mat thu nhat
glColor3f(0.0f,1.0f,0.0f);
glVertex3f(1.0f,1.0f,-1.0f);
glVertex3f(-1.0f,1.0f,-1.0f);
glVertex3f(-1.0f,1.0f,1.0f);
glVertex3f(1.0f,1.0f,1.0f);
// mat thu hai
glColor3f(1.0f,0.5f,0.0f);
glVertex3f(1.0f,-1.0f,1.0f);
glVertex3f(-1.0f,-1.0f,1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(1.0f,-1.0f,-1.0f);
// mat thu ba
glColor3f(1.0f,0.0f,0.0f);
glVertex3f(1.0f,1.0f,1.0f);
glVertex3f(-1.0f,1.0f,1.0f);
glVertex3f(-1.0f,-1.0f,1.0f);
glVertex3f(1.0f,-1.0f,1.0f);
// mat thu tu
glColor3f(1.0f,1.0f,0.0f);
glVertex3f(1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,1.0f,-1.0f);
glVertex3f(1.0f,1.0f,-1.0f);
// mat thu nam
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(-1.0f,1.0f,1.0f);
glVertex3f(-1.0f,1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,-1.0f);
glVertex3f(-1.0f,-1.0f,1.0f);
// mat thu sau
glColor3f(1.0f,0.0f,1.0f);
glVertex3f(1.0f,1.0f,-1.0f);
glVertex3f(1.0f,1.0f,1.0f);
glVertex3f(1.0f,-1.0f,1.0f);
glVertex3f(1.0f,-1.0f,-1.0f);
// glBegin(GL_POLYGON);
/*
glColor4f(1.0f,0.0f,0.0f,1.0f);
glVertex2f(100.0f,50.0f);
glColor4f(0.0f,1.0f,0.0f,1.0f);
______________________________________________________________________________________
56
ĐỒ ÁN TỐT NGHIỆP
glVertex2f(450.0f,400.0f);
glColor4f(0.0f,0.0f,1.0f,1.0f);
glVertex2f(450.0f,50.0f);
*/
glEnd();
// glFlush();
SwapBuffers(dc.m_ps.hdc);
}
//----------------------------------------------------------------------------
-------//
Bây giờ nếu chạy chƣơng trình ta sẽ thấy có 1 sự thay đổi.Tức là tòan bộ vùng
WorkSpace đã chuyển sang màu đen, nó chính là màu m c đ nh của OpenGL.
Hình 2.15 : Chạy thử project OpenGL
______________________________________________________________________________________
57
ĐỒ ÁN TỐT NGHIỆP
Sau khi đã tạo đƣợc 1 project OpenGL rồi, ta tiến hành xây dụng một khối lập
phuơng và có thể chuyển động đƣợc trong hệ trục tạo độ OXYZ mà cụ thể ở đây là
có thể quay quanh trục Z (trục thẳng đứng).
Bài toán đƣợc đ t ra là khối lập phƣơng quay quanh trục Z với 1 góc có thể thay
đổi đƣợc và ta gọi góc này là alpha, và góc này sẽ thay đổi liên tục theo thời gian
và hình lập phƣơng sẽ đƣợc vẽ xóa liên tục.Với tốc độ sử lý nhanh của OpenGL
thì ngƣời dùng sẽ cảm nhận đƣợc hình lập phƣơng đang quay quanh trục Z của
nó.Vấn đề là cái gì sẽ làm thay đổi alpha một cách đều đ n ? Không giống nhƣ
trong lập trình Pascal hay C/C++, môi trƣờng mà các ứng dụng lập trình b ng
Visual C
++
hoạt động là Windows, với cơ chế xử lý và hoạt động theo các thông
báo (Message).Do vậy dùng các vòng l p for hay while nó rất dễ phát sinh ra lỗi và
làm treo chƣơng trình. Trong Visual C++ có hỗ trợ Timer nên ta dùng nó để thay
đổi giá tr của alpha theo một khoảng thời gian đ nh sẵn.Đầu tiên ta thêm vào một
biến alpha, nhấp chuột phải vào lớp CDoanTinhocView,chọn Add Member
Variable.Sẽ có 1 cửa sổ hiện ra nhƣ sau :
Sau đó ta nhập vào Variable Type có kiểu là float, Variable Name là alpha, chọn
kiểu truy cập là Protected, rồi nhấn OK .Biến alpha sẽ đƣợc thêm vào .
float alpha; // Them vao bien alpha
Hình 2.16 : Thêm biến vào Project MFC
______________________________________________________________________________________
58
ĐỒ ÁN TỐT NGHIỆP
Trong cấu tử CDoanTinhocView::CDoanTinhocView() ta gán giá tr khởi đầu cho
biến alpha nhƣ sau :
CDoanTinhocView::CDoanTinhocView()
{
// TODO: add construction code here
m_hGLContext = NULL;
m_GLPixelIndex = 0;
alpha = 0.0f;
}
Dùng ClassWizard thêm vào OnTimer để đáp ứng thông báo WM_TIMER :
Và sau đó ta sửa lại mã lệnh nhƣ sau:
void CDoanTinhocView ::OnTimer(UINT nIDEvent)
{
Hình 2.17 : Chọn hàm OnTimer() để thiết lập thời gian chạy OpenGL
______________________________________________________________________________________
59
ĐỒ ÁN TỐT NGHIỆP
alpha +=0.5f;
SendMessage(WM_PAINT,0,0);
CView::OnTimer(nIDEvent);
}
Và sau đó trong hàm OnPaint() thêm vào lệnh .
glRotatef(alpha,0.0f,1.0f,0.0f);
Cuối cùng, trong hàm OnCreate, thêm lệnh khởi tạo Timer , với thời gian l p là
1ms.
SetTimer(ID_TIMER,1,NULL);
Vì ID_TIMER chƣa đƣợc khai báo, nên ta vào View\Resource Symbol nhƣ sau :
Hình 2.18 : Thiết lập cho hàm OnTimer()
______________________________________________________________________________________
60
ĐỒ ÁN TỐT NGHIỆP
Bấm vào New và có 1 cửa sổ hiện ta ta nhập vào ID_TIMER ở trong ô Name rồi
bấm OK.Sau đó bấm vào Close để kết thúc chƣơng trình.
Trong quá trình kết thúc hoạt động, Timer cần phải hủy do đó trong hàm
OnDestroy ta thêm vào dòng lệnh sau :
//------------------------------------------------------------------------//
void CDoanTinhocView::OnDestroy()
{
if(wglGetCurrentContext()!=NULL)
wglMakeCurrent(NULL,NULL);
if( m_hGLContext!=NULL)
{
wglDeleteContext(m_hGLContext);
m_hGLContext=NULL;
}
KillTimer(ID_TIMER);
// CView::OnDestroy();
}
//------------------------------------------------------------------------------//
Bây giờ ta chạy chƣơng trình, ta sẽ thấy hình lập phƣơng chuyển động theo các
phƣơng nhƣ hình vẽ ở dƣới đây.
Hình 2.19 : Thiết lập New Symbol
______________________________________________________________________________________
61
ĐỒ ÁN TỐT NGHIỆP
Hình 2.20 : Chạy thử 1 chương trình OpenGL
______________________________________________________________________________________
62
ĐỒ ÁN TỐT NGHIỆP
Nhƣ vậy, sau khi đã chạy thử thành công 1 project đƣợc tạo trên MFC và OpenGL
thì bƣớc tiếp theo là chúng ta phải đi vào xây dựng chƣơng trình mô phỏng của
Robot sau khi đã thiết kế mô hình trên Solidworks và vẽ lại trên OpenGL theo quỹ
đạo đã đƣợc tính toán và số hóa.
2.3 .Thiết kế mô hình Robot trên SolidWorks 2007.
Khi thiết kế mô hình của Robot trên Solidwork thì một điều rất quan trọng là việc
thiết lập các hệ tọa độ cho mô hình ban đầu để khi vẽ lại các chi tiết trên OpenGL
thì các chi tiết ko b nhảy lung tung. Ở đây em chọn hệ tọa độ khi vẽ trên
Solidwork trùng với các gốc tọa độ khi tính toán động học.Các chi tiết đƣợc thiết
kế trên Solidworks nhƣ sau :
______________________________________________________________________________________
63
ĐỒ ÁN TỐT NGHIỆP
Hình 2.21.Mô hình phần đề của Robot được thiết kế trên Solidwork
Hình 2.22.Mô hình Khâu 1của Robot được thiết kế trên Solidwork
______________________________________________________________________________________
64
ĐỒ ÁN TỐT NGHIỆP
Hình 2.32.Mô hình Khâu 2 của Robot được thiết kế trên Solidwork
______________________________________________________________________________________
65
ĐỒ ÁN TỐT NGHIỆP
Hình 2.32.Mô hình Khâu 3 của Robot được thiết kế trên Solidwork
______________________________________________________________________________________
66
ĐỒ ÁN TỐT NGHIỆP
Hình 2.32.Mô hình Khâu 4 của Robot được thiết kế trên Solidwork
______________________________________________________________________________________
67
ĐỒ ÁN TỐT NGHIỆP
Hình 2.19 : Bản lắp ghép đầy đủ của mô hình.
______________________________________________________________________________________
68
ĐỒ ÁN TỐT NGHIỆP
2.4 Xây dựng odule đọc File .*ST
2.4.1. Chuyển sang File .*STL
+ Sau khi ta thiết kế mô hình của Robốt trên Solidworks thì công việc tiếp theo là
ta sẽ chuyển nó sang file có đuôi là .*STL và xây dựng 1 chƣơng trình để đọc cấu
trúc của File *.STL và vẽ lại nó trên OpenGL.
+ Cách chuyển sang file STL theo các bƣớc nhƣ sau :
Bƣớc 1 : Ta mở mô hình đã đƣợc thiết kế b ng Solidworks sau đó từ mục File ->
Save As
Hình 2.19 : Chuyển sang File *.STL
______________________________________________________________________________________
69
ĐỒ ÁN TỐT NGHIỆP
Sau đó sẽ hiện ra các lựa chọn nhƣ sau :
- Save in : là tên của Folder để chứa file .*STL sau khi đã chuyển từ Solidwork
sang.
File name : là tên của File
Save type : ở đây ta chọn save lại là file dạng .*STL . 1 điều đáng chú ý ở đây là ta
chọn nút Options để ta đ nh dạng file .*STL có dạng là mã ASCII nhƣ hình ở dƣới.
Bƣớc 2 : Lựa chọn thƣ mục và kiểu file mà ta muốn chuyển .
H 2.27 : C yể ầ ế R s .*STL
______________________________________________________________________________________
70
ĐỒ ÁN TỐT NGHIỆP
Bƣớc 3 : Chọn file STL sau khi đã chuyển sang có dạng mã ASCII .
Khi thực hiện bƣớc này thì một điều rất quan trong là ta phải chọn vào : “Do not
translate STL output data to positive space ” để cho hệ tọa độ khi vẽ trong
Solidworks và khi chuyển sang file .*STL không b d ch chuyển.
H 2.28 : C ọ ị d f .* STL ASCII
______________________________________________________________________________________
71
ĐỒ ÁN TỐT NGHIỆP
Bước 4 : Hoàn tất việc chuyển sang file .*STL.
Nhƣ vậy qua 4 bƣớc ta đã chuyển 1 file từ Solidworks sang file .*STL và với cách
làm tƣơng tự ta sẽ chuyển tất cả các khâu của Robot sang file .*STL.
H 2.29 : C yể ế v â s f .*STL
______________________________________________________________________________________
72
ĐỒ ÁN TỐT NGHIỆP
2.4.2.Cấu trúc File *.STL
+ Phân tích cấu trúc của File .*STL.
solid CT1
facet normal 0.000000e+000 0.000000e+000 1.000000e+000
outer loop
vertex 2.000000e+001 7.347881e-015 5.200000e+002
vertex 6.657395e+001 2.163119e+001 5.200000e+002
vertex 1.732051e+001 1.000000e+001 5.200000e+002
endloop
endfacet
facet normal 0.000000e+000 0.000000e+000 1.000000e+000
outer loop
vertex 1.732051e+001 1.000000e+001 5.200000e+002
vertex 6.657395e+001 2.163119e+001 5.200000e+002
vertex 5.663119e+001 4.114497e+001 5.200000e+002
endloop
endfacet
facet normal 0.000000e+000 0.000000e+000 1.000000e+000
outer loop
vertex 1.732051e+001 1.000000e+001 5.200000e+002
vertex 5.663119e+001 4.114497e+001 5.200000e+002
H 2.29 : C yể ế v â s f .*STL
______________________________________________________________________________________
73
ĐỒ ÁN TỐT NGHIỆP
vertex 1.000000e+001 1.732051e+001 5.200000e+002
endloop
endfacet
facet normal 0.000000e+000 0.000000e+000 1.000000e+000
outer loop
vertex 1.732051e+001 -1.000000e+001 5.200000e+002
vertex 6.657395e+001 -2.163119e+001 5.200000e+002
vertex 2.000000e+001 7.347881e-015 5.200000e+002
endloop
endfacet
File *.STL có cấu trúc nhƣ sau : Cứ sau 7 dòng thì File lại có cấu trúc lại l p lại từ
đầu. Dòng đầu tiên trong File *.STL bao giờ cũng là tên của chi tiết mà khi vẽ ta
đ t trên Solidworks.Sau đó đến các Vector pháp tuyến của bề m t cần vẽ và tọa độ
của 3 đ nh.Nhƣ vậy File *.STL đã số hóa các chi tiết thành rất nhiều bề m t nhỏ
hơn và các đ nh tƣơng ứng với nó.Từ đây ta có cơ sở để xây dựng Module đọc File
*.STL phục vụ quá trình mô phỏng.
2.4.3.Xây dựng hàm đọc file *.ST
+ Chƣơng trình đọc File *.STL
Trong Module này em xin trình bày 2 cách để đọc File *.STL và vẽ lại trên môi
trƣờng đồ họa OpenGL.
Cách 1: Trong cách này thì hàm ReadModel(GLint &model, string filename) sẽ
lƣu toàn bộ các thông tin về các vector pháp tuyến và các đ nh vào glGenLists(1)
và vẽ lại với chu trình là cứ 3 điểm sẽ vẽ thành 1 bề m t và chu trình vẽ đã đƣợc
đ t trong 1 vòng l p while cho đến khi đọc hết File *.STL và vẽ hoàn ch nh các bề
m t của chi tiết thì mới thôi.Tuy nhiên,cách này với số lƣợng file *.STL nhiều thì
sẽ làm cho chƣơng trình b đơ nên em xin giới thiệu cách thứ hai.
#ifndef _READ_FILE_STL_H_
#define _READ_FILE_STL_H_
//#include "stdlib.h"
#include "string"
#include "fstream"
using namespace std;
______________________________________________________________________________________
74
ĐỒ ÁN TỐT NGHIỆP
void ReadModel(GLint &model, string filename)
{
model = glGenLists(1);
if(model !=0)
{
GLdouble n[3], v[3][3];
ifstream ifs(filename.c_str());
// ifs.setmode(filebuf::binary);
string str1, str2;
//Start READ STL FILE
getline(ifs, str1);//"solid ..."
glNewList(model, GL_COMPILE);
glBegin(GL_TRIANGLES);
while(1)
{
//'face' OR 'endsolid'
ifs>>str1;
if(str1 == "endsolid")
break;
//n[0] n[1] n[2]
ifs>>str1>>n[0]>>n[1]>>n[2];
getline(ifs, str1);
//outer loop
getline(ifs, str1);
//Vertex1, Vertex2, Vertex3
for(int i=0; i<3; ++i)
{
ifs>>str1>>v[i][0]>>v[i][1]>>v[i][2];
getline(ifs, str1);
}
//Draw a triangle
glNormal3dv(n);
glVertex3dv(v[0]);
glVertex3dv(v[1]);
glVertex3dv(v[2]);
//end loop
getline(ifs, str1);
//end face
getline(ifs, str1);
}
glEnd();
glEndList();
ifs.close();
}
}
#endif _READ_FILE_STL_H_
Cách 2 : Trong cách này thì ta viết 1 hàm để đọc file *.STL .Đoạn đầu của hàm
ReadFileSTL() là các khai báo các biến cục bộ, tiếp sau đó là đến dòng lệnh :
f=fopen("ROBOT.txt","rt");
______________________________________________________________________________________
75
ĐỒ ÁN TỐT NGHIỆP
Đây chính là 1 file *.txt chứa ở trong thƣ mục của chƣơng trình và nội dung của
file là chứa danh sách các chi tiết đã vẽ trên Solidwork và đã chuyển sang file
*.STL để trong quá trình mô phỏng nó sẽ vẽ lại mô hình của Robot.
Tiếp theo là các câu lệnh if else while để tiến hành kiểm tra file và đọc file
*.STL. Nếu việc mở File thành công thì chƣơng trình sẽ tiến hành đọc đọc tên của
các tệp số liệu và và lƣu vào mảng filechitiet[]. Kết thúc việc đọc trong File
ROBOT.txt thì biến số chi tiết sẽ đƣợc gán giá tr cho tổng số file cần nạp.
Tiếp theo là lệnh lisct = glGenLists(SOCHITIET) là lệnh khởi tạo môt danh sách
list gồm có số phần tử b ng số chi tiết.Mục đích là tạo ra một list để thực hiện các
thao tác vẽ rồi lƣu vào mảng danh sách.Trong quá trình mô phỏng,ch cần gọi ra
mà không cần tiến hành vẽ lại.Nhƣ vậy sẽ tối ƣu cho quá trình mô phỏng,sau đó
H 2.29 : C yể ế v â s f .*STL
______________________________________________________________________________________
76
ĐỒ ÁN TỐT NGHIỆP
chƣơng trình sẽ thực hiện mở từng file số liệu đã đƣợc lƣu trong mảng
filechitiet[].Nếu quá trình mở file thành công,quá trình tiếp theo là việc nạp và vẽ
lại chi tiết đƣợc thực hiện theo lệnh sau :
glNewList(listct+loop,GL_COMPILE)
lệnh này tạo ra 1 list mới để lƣu quá trình vẽ của chi tiết đang cần nạp.Chƣơng
trình đọc số liệu theo cấu trúc tệp số liệu đã phân tích ở trên.Tiếp theo đó, lệnh
Vemat() là một hàm thực hiện chức năng vẽ một m t, với các tham số đầu vào là 3
vector chứa tọa độ của 3 đ nh.Các lệnh của hàm Vemat() nhƣ sau:
void CMophongView::Vemat(float *p1, float *p2, float *p3)
{
glVertex3f(p1[0],p1[1],p1[2]);
glVertex3f(p2[0],p2[1],p2[2]);
glVertex3f(p3[0],p3[1],p3[2]);
}
Tất cả mã lệnh của hàm đọc File *.STL nhƣ dƣới đây.
void CMophongView::ReadFileSTL() //Ham nay co chuc nang la doc File .*STL
{
unsigned int SOCHITIET;
FILE *f;
char st[216]="";
char filechitiet[100][256];
char xaudoc[216]="";
float dinh[1000][3];
float d1,d2,d3; //Toa do cac dinh cua moi facet
float i1,i2,i3; //Vecto phap tuyen tuong ung
unsigned int i,j;
unsigned int loop;
char catbo[20]="";
f=fopen("ROBOT.txt","rt");
if(f==NULL)
{
MessageBox("Khong tim thay file chua danh sach cac chi
tiet!\n","Thong bao");
ExitThread(0);
}
else
{
loop=0;
while(!feof(f))
{
fscanf(f,"%s",st);
sprintf(filechitiet[loop],"%s.STL",st);
loop++;
______________________________________________________________________________________
77
ĐỒ ÁN TỐT NGHIỆP
}
fclose(f);
srand((unsigned) time(NULL));
SOCHITIET=loop;
for (i=0;i<SOCHITIET;i++)
for (j=0;j<3;j++)
mauchitiet[i][j]=(float)rand()/RAND_MAX;
}
listct=glGenLists(SOCHITIET);
for(loop=0;loop<SOCHITIET;loop++)
{
fopen(filechitiet[loop],"rt");
glNewList(listct+loop,GL_COMPILE);
glBegin(GL_TRIANGLES);
fgets(xaudoc,256,f);
while(!feof(f))
{
fgets(xaudoc,256,f);
sscanf(xaudoc,"%16c%f%f%f",&catbo,&i1,&i2,&i3);
if (!feof(f))
{
fgets(xaudoc,256,f);
for (i=1;i<4;i++)
{
fgets(xaudoc,256,f);
sscanf(xaudoc,"%16c%f%f%f",&catbo,&d1,&d2,&d3);
dinh[i][0]= d1;
dinh[i][1]= d2;
dinh[i][2]= d3;
}
glNormal3f(i1,i2,i3);
Vemat(dinh[1],dinh[2],dinh[3]);
fgets(xaudoc,256,f);
fgets(xaudoc,256,f);
}
}
fclose(f);
glEnd();
glEndList();
}
Hàm CalcNormal(float *p1, float *p2, float *p3)
Là hàm xác đ nh pháp tuyến của bề m t cần vẽ. Nhờ có pháp tuyến này nên khi
thực hiện gán vật liệu và chiếu sáng cho vật thể cần mô phỏng, OpenGL mới nhận
ra và xử lý đúng đƣợc. Các đoạn mã trong hàm này đƣợc viết nhƣ ở dƣới đây.
void CMophongView::CalcNormal(float *p1, float *p2, float *p3)
{
______________________________________________________________________________________
78
ĐỒ ÁN TỐT NGHIỆP
float a[3],b[3];
a[0]=p2[0]-p1[0];
a[1]=p2[1]-p1[1];
a[2]=p2[2]-p1[2];
b[0]=p3[0]-p1[0];
b[1]=p3[1]-p1[1];
b[2]=p3[2]-p1[2];
n[0]=(a[1]*b[2])-(a[2]*b[1]);
n[1]=(a[2]*b[0])-(a[0]*b[2]);
n[2]=(a[0]*b[1])-(a[1]*b[0]);
float length = sqrtf(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]);
if(length!=0)
{
n[0]=n[0]/length;
n[1]=n[1]/length;
n[2]=n[2]/length;
}
}
2.4.4. Số hóa quỹ đạo chuyển động của ROBOT.
Sau các bƣớc nhƣ trên, thì ta đã có mô hình của Robot nhƣng chƣa thể mô phỏng
hoạt động của chúng đƣợc vì chƣa xây dựng quy luật chuyển động cho cơ các cơ
cấu. Trong phần tính toán động học cho ROBOT,nhóm đã viết 1 chƣơng trình tính
toán động học cho Robot trên ngôn ngữ lập trình Visual C++ và vẽ quỹ đạo cần gia
công trên AutoCAD sau đó số hóa ra 1 file *.txt với các số liệu đầy đủ phục vụ cho
quá trình mô phỏng với các thông số nhƣ sau:
+ q1 – góc quay của khâu 1 quanh trục OZ1.
+ q2 – góc quay của khâu 2 quanh trục OZ2.
+ q3 – chuyển động t nh tiến của Xilanh trong Pistong thủy lực.
+ q4 – Góc quay của khâu 4 quanh trục OZ4.
+ X – Y – Z : là toạ độ của bàn kẹp của cánh tay Robot.
+ deltaq1 : goc sau trừ góc trƣớc.
______________________________________________________________________________________
79
ĐỒ ÁN TỐT NGHIỆP
+ deltaq2
+ deltaq3
+ detaq4
File Số hóa quỹ đạo chuyển động sau khi xuất ra có cấu trúc nhƣ sau :
+ Dòng đầu tiên : Tọa độ X-Y-Z.
+ Dòng thứ hai : q1- q2 - q3- q4
+ Dòng thứ ba :deltaq1-deltaq2-deltaq3-deltaq4.
Cứ sau 3 dòng thì chu trình của File quỹ đạo lại quay trở về lúc đầu tức là trở về
các tọa độ X-Y-Z .
234.868 195.568 162
1.3672 -1.88065 258 1.44725
-0.000332801 -0.00128424 -6.28014e-006 0.00063094
234.807 195.266 162
1.36687 -1.88193 258 1.44788
-0.000337478 -0.00127908 -6.28014e-006 0.00063388
234.747 194.964 162
1.36653 -1.88321 258 1.44851
-0.000342079 -0.00127421 2.27443e-005 0.000636818
234.687 194.663 162
1.36619 -1.88448 258 1.44915
-0.000346807 -0.00126877 -6.33672e-006 0.000639754
234.629 194.361 162
1.36584 -1.88575 258 1.44979
-0.000351456 -0.00126362 -6.11041e-006 0.000642686
234.571 194.059 162
1.36549 -1.88702 258 1.45043
-0.000356098 -0.00125849 -6.33672e-006 0.000645617
234.515 193.758 162
1.36514 -1.88828 258 1.45108
-0.000360663 -0.00125365 2.26311e-005 0.000648545
234.459 193.456 162
1.36478 -1.88953 258 1.45172
-0.000365352 -0.00124823 -6.33672e-006 0.00065147
234.405 193.154 162
1.36441 -1.89078 258 1.45238
-0.000369964 -0.00124312 -5.8841e-006 0.000654391
234.351 192.853 162
1.36404 -1.89202 258 1.45303
-0.000374569 -0.00123801 -6.33672e-006 0.000657312
______________________________________________________________________________________
80
ĐỒ ÁN TỐT NGHIỆP
2.4.5. Xây dựng module đọc File quỹ đạo đã đƣợc số hóa.
Với cấu trúc File quỹ đạo nhƣ trên, Module để đọc file quỹ đạo có dạng nhƣ sau :
void CMophongView::Docsolieuquydao() // Quy dao duoc tinh toan va so hoa tren
CAD.
{
// Thuc hien qua trinh doc File so lieu cua quy dao chuyen dong.
// Doc vao cac thong so X-Y-Z de ve quy dao
// Doc vao cac thong so q1 - q2 - q3 - q4.
FILE *f;
char st[256]=""; // Xau can doc .
float temp0,temp1,temp2; // Luu tru cac bien X-Y-Z.
float k1,k2,k3,k4; // Luu tru cac bien q1 - q2 - q3 - q4.
bool ngungnap = FALSE;
int i,j;
float X,Y,Z;
f=fopen("DiscreteSpline.txt","rt"); // Doc vao File so lieu cua quy dao.
// Kiem tra xem File co ton tai hay khong.
if (f == NULL)
{
sprintf(st,"Khong thay file chua thong so quy dao!");
MessageBox(st);
ExitThread(0);
}
// Bat dau doc File.
while(!feof(f))
{
// dong thu nhat.
fgets(st,256,f); // Doc vao 1 xau
sscanf(st,"%f%f%f",&temp0,&temp1,&temp2);
t[vitri][0] = temp0; // X.
t[vitri][1] = temp1; // Y.
t[vitri][2] = temp2; // Z.
//dong thu 2
fgets(st,256,f);
sscanf(st,"%f%f%f%f",&k1,&k2,&k3,&k4);
q[vitri][0] = k1;
q[vitri][1] = k2;
q[vitri][2] = k3;
q[vitri][3] = k4;
//dong thu 3
fgets(st,256,f);
vitri++;
}
fclose(f);
}
______________________________________________________________________________________
81
ĐỒ ÁN TỐT NGHIỆP
Các dòng đầu tiên là khai báo các biến cục bộ và khi đến dòng này thì b t đầu mở
file quỹ đạo.
f=fopen("DiscreteSpline.txt","rt"); // Doc vao File so lieu cua quy dao.
Sau đó kiểm tra quá trình đọc file, nếu thành công thì mở file và b t đầu đọc file và
lƣu vào xâu st[256].
2.5. ô phỏng chƣơng trình trên OpenG .
Sau khi thực hiện xong các bƣớc ở trên nhƣ khởi tạo 1 Project MFC và include các
gói thƣ viện của OpenGL em đã xây dựng đƣợc 1 khung giao diện tổng quát cho
bài toán mô phỏng hoạt động của Robot nhƣ sau :
______________________________________________________________________________________
82
ĐỒ ÁN TỐT NGHIỆP
H 2.38 : M R S ã ợ vẽ ên OpenGL
______________________________________________________________________________________
83
ĐỒ ÁN TỐT NGHIỆP
CHƢƠNG 3
CHẠY CHƢƠNG TRÌNH PHỎNG
KẾT UẬN
______________________________________________________________________________________
84
ĐỒ ÁN TỐT NGHIỆP
Nhƣ vậy, trong Đồ án tin học ứng dụng này em đã tìm hiểu và trình bày
xong cách xây dựng một chƣơng trình mô phỏng hoạt động của Robot Công nghiệp
với sự hỗ trợ của các phần mềm nhƣ SolidWorks,AutoCAD,VisualC++, OpenGL.
Trong toàn bộ đồ án này em đã hoàn thành đƣợc các vấn đề sau :
+ Về m t lý thuyết:
- N m vững đƣợc và biết cách áp dụng cơ sở lý thuyết để xây dựng
các chƣơng trình mô phỏng chuyển động cho robot.
- N m vững đƣợc quy trình giải quyết các bài toán tính toán, thiết kế,
mô phỏng và điều khiển.
- Hiểu và biết cách sử dụng các chƣơng trình phần mềm nhƣ AutoCad,
OpenGL, DirectX,MFC, Maple, ObjectARX để lập trình mô phỏng.
+ Về m t thực hành
- Xây dựng đƣợc 1 chƣơng trình để mô phỏng hoạt động của Robot
với các chức năng cơ bản nhƣ chạy chƣơng trình, dừng chƣơng trình
và k o thả chuột khi tƣơng tác với mô hình họat động của Robot.
- Xây dựng đƣợc các module về các phần trong chƣơng trình mô
phỏng nhƣ đọc các file .*STL và .*BDF để tiến hành mô phỏng các
chuyển động của RobotScara 4 bậc tự do.
Tuy nhiên, còn có một số vấn đề em chƣa giải quyết đƣợc đó là :
- Chƣa tìm hiểu đƣợc nhiều và sâu về ObjectARX để số hóa đƣờng
thẳng và đƣờng cong mà em mới ch áp dụng module ff2k.arx có sẵn
để số hóa thực hiện cho quá trình mô phỏng.
______________________________________________________________________________________
85
ĐỒ ÁN TỐT NGHIỆP
- Chƣơng trình mô phỏng mới ch áp dụng đƣợc cho một loại Robot,
chƣa áp dụng đƣợc cho nhiều cơ cấu hay nhiều loại Robot và ch đọc
đƣợc một loại file là .*BDF trong quá trình mô phỏng.
- Chƣơng trình mô phỏng sử dụng gói thƣ viện đồ họa OpenGL để
mô phỏng. Tuy nhiên, nếu xây dựng trên DirectX thì đạt đƣợc một
số hiệu quả cao hơn nhƣ tốc độ xử lý và hiển th hình ảnh, chất
lƣợng hình ảnh.
+ Về phƣơng hƣớng phát triển:
- Xây dựng một chƣơng trình (Project) hoàn thiện để mô phỏng tất cả
các lại Robot và các cơ cấu động học khác nhau.
- Xây dựng chƣơng trình với tốc độ sử lý Đồ họa nhanh hơn,đọc các
File dữ liệu nhanh hơn mà không b đơ chƣơng trình.
- Phát triển chƣơng trình có thể đọc đƣợc 2 loại file là .*STL và
.*BDF cùng trong 1 chƣơng trình.
- Qua đồ án tin học ứng dụng này em đã có cơ sở để xây dựng các bài
toàn mô phỏng hoạt động của Robot và là nền tảng vững ch c để em
thực hiện đồ án tốt nghiệp sau này.
______________________________________________________________________________________
86
ĐỒ ÁN TỐT NGHIỆP
TÀI IỆU THA KHẢO
1. GS.TSKH.Nguyễn Văn Khang, Độ ọ ề v , NXB Khoa học và
Kỹ thuật, Hà Nội 2007, 335 tr.
1 GS.TSKH.Nguyễn Thiện Phúc, R , NXB Khoa học và Kỹ
thuật, Hà Nội 2006, 342 tr.
2 GS.Phạm Văn Ất, C++ & ố ợ , NXB Khoa học và Kỹ
Thuật, Hà Nội 2000, 636 tr.
3 Phạm Công Ngô, V s C++6.0, NXB T ố Kê, Hà Nội 2002, 700 tr.
4 Neon Helium Productions, OpenGL Tutorial.
5 Addison Wesley Publishing Company, OpenGL Programming Guide.
1 – Cách tạo ra File .*STL
- cấu trúc của File .*STL.
- Modun đọc File .*STL --- và vẽ lại nó trên OpenGL.
Các Modun chính trong chƣơng trình Mô phỏng hoạt động của Robot Công
nghiệp.
Các file đính kèm theo tài liệu này:
- 74574641-Do-an-Tot-Nghiep-31-05-2009.pdf