Luận án Hệ thống điều khiển robot tự hành qua mạng trong môi trường công nghiệp

Cuộc cách mạng công nghiệp lần thứ nhất được đánh dấu bằng sự ra đời của

máy hơi nước vào năm 1784 và việc sử dụng năng lượng nước, hơi nước vào

trong cơ giới hóa sản xuất. Cuộc cách mạng công nghiệp lần thứ hai bắt đầu từ

năm 1870 với việc sử dụng năng lượng điện, và sự ra đời của dây chuyền sản

xuất hàng loạt qui mô lớn. Cuộc cách mạng công nghiệp lần thứ ba bắt đầu từ

năm 1969 với sự lan tỏa của việc sử dụng công nghệ điện tử, công nghệ thông

tin để đưa vào tự động hóa sản xuất. Và từ năm 2015, cuộc cách mạng công

nghiệp lần thứ tư (Industry 4.0) đã chính thức bắt đầu. Đặc trưng của Industry

4.0 là sự kết hợp xóa bỏ ranh giới giữa hệ thống sản xuất, quản lí và quản trị với

các yếu tố kỹ thuật cốt lõi là: Trí tuệ nhân tạo (Artificial Intelligence – AI), kết

nối vạn vật (Internet of Thing – IoT), phân tích dữ liệu lớn (Big Data), bảo mật

hệ thống chuỗi (Block Chain). Industry 4.0 tác động vào tất cả các lĩnh vực như:

robot, công nghệ sinh học, y sinh, nông nghiệp, công nghệ nano, in 3D, và robot

tự hành (xe ô tô và robot tự hành).v.v.

Việc tác động của Industry 4.0 đến lĩnh vực robot tự hành sẽ tạo nên một hệ

thống vận chuyển hàng trong nhà xưởng, nhà kho mang tính linh hoạt cao, tạo

điều kiện thuận lợi cho các hoạt động quản lí, quản trị như: Hoạch định quỹ đạo

di chuyển, tối ưu hóa quỹ đạo theo tiêu chí tối thiểu năng lượng tiêu thụ hoặc

thời gian di chuyển nhanh nhất, tránh vật cản, kiểm soát lưu lượng hàng hóa,

đánh giá năng lực sản xuất và luân chuyển hàng hóa. Để hiện thực hóa hệ thống

với các chức năng trên, các robot tự hành có khả năng kết nối với bộ điều khiển

trung tâm từ xa nhằm chia sẻ các thông tin như: vị trí hiện tại, tác vụ hiện hành,

tình trạng hoạt động. Đồng thời chúng cũng có thể kết nối và chia sẻ thông tin

với nhau tạo thành mạng chia sẻ ngang hàng giữa chúng với bộ điều khiển trung

tâm. Với việc triển khai cấu trúc điều khiển qua mạng của hệ thống robot tự

hành, cho phép các nhà quản lí thay đổi thông số động học như vận tốc, quỹ đạo

và tác vụ của robot một cách linh hoạt, nhanh chóng. Tuy nhiên, do hệ thống2

này tập trung nhiều thiết bị với số lượng thông tin chia sẻ lớn, nên sẽ gây tổn

hao băng thông trên đường truyền, điều này phát sinh hai vấn đề: Mất gói dữ

liệu trên đường truyền và thời gian trễ sinh ra trên đường truyền. Việc mất gói

dữ liệu trên đường truyền có thể giải quyết bằng các giao thức truyền với cơ chế

quản lí chất lượng dịch vụ (Quality of Servive – QoS) kiểm soát tổng số gói tin,

yêu cầu gửi bù những gói tin bị thiếu, gửi lại những gói tin bị thiếu. Tuy nhiên,

thời gian trễ sinh ra trên đường truyền ngoài yếu tố băng thông, còn do nguyên

nhân tốc độ đường truyền, cơ chế QoS, và thời gian xử lí của thiết bị đầu cuối.

Mặt khác, thời gian trễ trên đường truyền còn làm giảm chất lượng điều khiển

của hệ thống robot tự hành hoặc thậm chí làm mất tính ổn định của hệ thống. Do

vậy, việc xây dựng hệ thống điều khiển robot tự hành qua mạng trong đó nghiên

cứu giải quyết, khắc phục vấn đề thời gian trễ trên đường truyền nhằm giảm ảnh

hưởng đến chất lượng điều khiển của hệ thống là điều cần thiết mang tính khoa

học và thực tiễn.

Luận án này đặt ra các vấn đề nghiên cứu như sau:

Mục tiêu nghiên cứu: Tìm ra giải pháp dựa trên cơ sở điều khiển, ước lượng

với các thông tin được chia sẻ trong hệ thống điều khiển robot tự hành qua mạng

nhằm giảm ảnh hưởng của yếu tố thời gian trễ đến chất lượng điều khiển của hệ

thống, đảm bảo tính ổn định cho hệ thống hoạt động trong môi trường công

nghiệp với độ tin cậy trong phạm vi cho phép.

Đối tượng nghiên cứu: Hệ thống điều khiển robot tự hành với phương thức

giao tiếp qua mạng không dây (Internet).

Phạm vi nghiên cứu: Luận án đề xuất các bộ điều khiển phát triển dựa trên

mô hình hóa động học và động lực học của robot tự hành đồng thời kết hợp các

thuật toán bám theo quỹ đạo, thích nghi theo hệ thống tham chiếu, kỹ thuật thiết

kế hệ thống đệ quy, nhằm làm giảm ảnh hưởng của thời gian trễ được đánh giá

bằng hiệu suất hoạt động của robot tự hành trên mô phỏng và tạo tiền đề cho

thực nghiệm.3

Giới hạn của luận án: Robot tự hành là một hệ thống phức hợp nhiều bài

toán gồm điều khiển bám theo quỹ đạo, điều khiển bám theo quỹ đạo đảm bảo

yếu tố động lực học, quản lí năng lượng, định vị trong môi trường trong nhà.

Luận án này giới hạn ở việc chỉ xây dựng bộ điều khiển bám theo quỹ đạo trong

sự hiện diện của thời gian trễ và các thông số hệ thống không thể xác định chính

xác.

- Luận án không tập trung phát triển thuật toán xác định vị trí cho robot tự

hành mà sử dụng thuật toán truyền thống dead-reckoning, còn được gọi là

phương pháp odometry.

- Luận án không tập trung phát triển giải thuật hoạch định và tối ưu hóa quỹ

đạo cho robot tự hành

pdf 237 trang chauphong 16/08/2022 3760
Bạn đang xem 20 trang mẫu của tài liệu "Luận án Hệ thống điều khiển robot tự hành qua mạng trong môi trường công nghiệp", để tải tài liệu gốc về máy hãy click vào nút Download ở trên

Tóm tắt nội dung tài liệu: Luận án Hệ thống điều khiển robot tự hành qua mạng trong môi trường công nghiệp

Luận án Hệ thống điều khiển robot tự hành qua mạng trong môi trường công nghiệp
BỘ GIÁO DỤC VÀ ĐÀO TẠO BỘ CÔNG THƯƠNG 
VIỆN NGHIÊN CỨU ĐIỆN TỬ, TIN HỌC, TỰ ĐỘNG HÓA 
---***--- 
NGUYỄN TRỌNG TRUNG 
HỆ THỐNG ĐIỀU KHIỂN ROBOT TỰ HÀNH QUA MẠNG 
TRONG MÔI TRƯỜNG CÔNG NGHIỆP 
CHUYÊN NGÀNH: KỸ THUẬT ĐIỆN TỬ 
MÃ SỐ: 9520203 
LUẬN ÁN TIẾN SĨ KỸ THUẬT 
TP Hồ Chí Minh - 2021
i 
 LỜI CAM ĐOAN 
Tôi xin cam đoan rằng nội dung của luận án này là kết quả nghiên cứu của 
riêng tác giả. Tất cả những tham khảo từ các nghiên cứu liên quan đều được nêu 
nguồn gốc một cách rõ ràng. Những kết quả nghiên cứu và đóng góp trong luận 
án chưa được công bố trong bất kỳ công trình khoa học nào khác. 
Tác giả luận án 
Nghiên cứu sinh 
Nguyễn Trọng Trung 
ii 
LỜI CẢM ƠN 
Tôi xin bày tỏ lòng biết ơn sâu sắc đến hai Thầy hướng dẫn: PGS. TS. 
Nguyễn Thanh Phương và TS. Trần Viết Thắng đã tận tình hướng dẫn tôi thực 
hiện các công trình nghiên cứu và hoàn thành luận án này. 
Tôi xin chân thành cảm ơn các Thầy, Cô, Cán bộ, Nhân viên của Viện 
Nghiên cứu Điện tử, Tin học, Tự động hóa và Phân Viện Nghiên cứu Điện tử, 
Tin học, Tự động hóa TP.HCM đã nhiệt tình giúp đỡ, tạo điều kiện thuận lợi cho 
tôi trong suốt thời gian học tập và nghiên cứu. 
Cuối cùng, xin bày tỏ lòng biết ơn chân thành đến Gia đình của tôi, những 
người thân đã chia sẻ mọi khó khăn, luôn động viên tôi vượt qua khó khăn để 
hoàn thành tốt luận án này. 
iii 
MỤC LỤCS 
LỜI CAM ĐOAN ................................................................................................... i 
LỜI CẢM ƠN ....................................................................................................... ii 
MỤC LỤC ............................................................................................................ iii 
DANH MỤC CÁC TỪ VIẾT TẮT ..................................................................... vi 
DANH MỤC CÁC ĐƠN VỊ ĐO LƯỜNG ........................................................ viii 
DANH MỤC HÌNH VẼ ....................................................................................... ix 
DANH MỤC BẢNG BIỂU ............................................................................... xii 
DANH MỤC KÍ HIỆU ...................................................................................... xiii 
MỞ ĐẦU ............................................................................................................... 1 
CHƯƠNG 1: TỔNG QUAN VỀ HỆ THỐNG ĐIỀU KHIỂN ROBOT TỰ 
HÀNH QUA MẠNG ............................................................................................ 6 
1.1. Giới thiệu về hệ thống vật lí ảo cho hệ thống kho vận nội bộ trong môi 
trường công nghiệp ....................................................................................... 6 
1.2. Giới thiệu về hệ thống điều khiển qua mạng cho robot tự hành ................. 13 
1.2.1. Giới thiệu chung.............................................................................. 13 
1.2.2. Hệ thống điều khiển robot tự hành qua mạng ................................. 20 
1.3. Các vấn đề cần giải quyết ........................................................................... 25 
1.4. Tình hình nghiên cứu .................................................................................. 30 
1.4.1. Về hệ thống có thời gian trễ ............................................................ 30 
1.4.2. Về điều khiển robot tự hành có thời gian trễ .................................. 36 
1.5. Kết luận ....................................................................................................... 41 
CHƯƠNG 2: XÂY DỰNG MÔ HÌNH HÓA ROBOT TỰ HÀNH TRONG SỰ 
ẢNH HƯỞNG CỦA THỜI GIAN TRỄ ............................................................. 43 
2.1. Mô tả hệ thống ............................................................................................ 43 
2.2. Mô hình động học của robot tự hành .......................................................... 46 
2.3. Mô hình động lực học của robot tự hành .................................................... 47 
2.4. Mô hình hóa thời gian trễ ............................................................................ 53 
iv 
2.5. Kết luận chương 2 ....................................................................................... 57 
CHƯƠNG 3: THIẾT KẾ BỘ ĐIỀU KHIỂN BÁM THEO QUỸ ĐẠO MONG 
MUỐN CHO ROBOT TỰ HÀNH VỚI TÍN HIỆU TRỄ ĐẦU VÀO .............. 59 
3.1. Thuật toán bám theo quỹ đạo mong muốn .................................................. 60 
3.2. Hệ thống tham chiếu của mô hình ổn định ................................................. 65 
3.3. Bộ điều khiển thích nghi theo hệ thống tham chiếu cho hệ thống một ngõ 
vào – một ngõ ra. ......................................................................................... 71 
3.4. Bộ điều khiển thích nghi theo hệ thống tham chiếu cho robot tự hành ...... 83 
3.5. Kết luận chương 3 ....................................................................................... 92 
CHƯƠNG 4: KẾT QUẢ .................................................................................. 94 
4.1. Cấu trúc hệ thống ........................................................................................ 94 
4.1.1. Cấu hình điều khiển qua mạng ....................................................... 94 
4.1.2. Cấu trúc robot tự hành .................................................................... 95 
4.1.3. Cấu trúc trao đổi dữ liệu qua mạng................................................. 97 
4.2. Thiết lập mô phỏng ................................................................................... 100 
4.3. Kết quả mô phỏng trên Matlab ................................................................. 103 
4.3.1. Trường hợp 1 – Không có thời gian trễ ........................................ 103 
4.3.2. Trường hợp 2 – Thời gian trễ 0.01 giây ....................................... 108 
4.3.3. Trường hợp 3 – Thời gian trễ 0.05 giây ....................................... 112 
4.3.4. Trường hợp 4 – Thời gian trễ 0.1 giây.......................................... 115 
4.4. Thực nghiệm xác định thời gian trễ .......................................................... 120 
4.5. Kết quả thực nghiệm điều khiển robot tự hành ảo qua mạng ................... 124 
4.6. Kết luận chương 4 ..................................................................................... 130 
Kết luận ............................................................................................................. 133 
CÔNG TRÌNH CÔNG BỐ TẠP CHÍ ............................................................... 137 
CÔNG TRÌNH CÔNG BỐ HỘI NGHỊ ............................................................ 138 
TÀI LIỆU THAM KHẢO ................................................................................. 139 
PHỤ LỤC .......................................................................................................... 152 
A.1 Chương trình mô phỏng hệ thống tham chiếu .......................................... 152 
v 
A.2 Chương trình mô phỏng bộ điều khiển thích nghi theo hệ thống tham chiếu 
cho hệ thống một ngõ vào – một ngõ ra. ................................................... 154 
A.3 Chương trình mô phỏng bộ điều khiển thích nghi theo hệ thống tham chiếu 
cho robot tự hành – Trường hợp không có thời gian trễ ........................... 160 
A.4 Chương trình mô phỏng bộ điều khiển thích nghi theo hệ thống tham chiếu 
cho robot tự hành – Trường hợp thời gian trễ 10ms ................................. 170 
A.5 Chương trình mô phỏng bộ điều khiển thích nghi theo hệ thống tham chiếu 
cho robot tự hành – Trường hợp thời gian trễ 50ms ................................. 180 
A.6 Chương trình mô phỏng bộ điều khiển thích nghi theo hệ thống tham chiếu 
cho robot tự hành – Trường hợp thời gian trễ 100ms ............................... 189 
A.7 Chương trình phần mềm đo thời gian trễ ở tầng mạng ............................. 199 
A.8 Chương trình phần mềm đo thời gian trễ ở tầng ứng dụng – Thành phần 
nguồn ......................................................................................................... 201 
A.9 Chương trình phần mềm đo thời gian trễ ở tầng ứng dụng – Thành phần 
đích ............................................................................................................ 205 
A.10 Chương trình phần mềm mô phỏng động học/động lực học của robot tự 
hành ........................................................................................................... 208 
A.11 Chương trình phần mềm điều khiển và giao diện của bộ điều khiển trung 
tâm ............................................................................................................. 211 
vi 
DANH MỤC CÁC TỪ VIẾT TẮT 
AC Alternative current Dòng điện xoay chiều 
ACK Acknowledgement Hồi đáp 
AGV Automated guided vehicle Phương tiện tự hành 
CAN Controlled Area Network Mạng điều khiển nội bộ 
CSMA/CD Carrier Sense Multiple Access 
/ Collision Detection 
DC Direct current Dòng điện một chiều 
DCS Distributed control system Hệ thống điều khiển phân tán 
FTP File Transfer Protocol Giao thức truyền tải tập tin 
HMI Human machine interface Giao diện người - máy 
HTTP Hypertext Transfer Protocol Giao thức truyền tải siêu văn bản 
HTTPS Hypertext Transfer Protocol 
Secure 
Giao thức truyền tải siêu văn bản 
bảo mật 
ID Identifier Mã định danh 
IMU Inertia measurement unit Thiết bị đo lường quán tính 
IP Internet protocol Giao thức mạng 
LAN Local Area Network Mạng giao tiếp nội bộ 
LQR Linear Quadratic Regulator 
MIMO Multi input multi output Hệ thống nhiều ngõ vào nhiều ngõ 
ra 
MRAC Model reference adaptive 
control 
Bộ điều khiển thích nghi theo mô 
hình tham chiếu chuẩn 
MQTT Message Queuing Telemetry 
Transport 
Giao thức truyền thông điệp theo mô 
hình cung cấp/thuê bao 
NCS Networked control system Hệ thống điều khiển qua mạng 
truyền thông 
NTP Network Time Protocol 
PC Personal computer Máy tính 
PI Proportional – Integral Bộ điều khiển tỉ lệ - tích phân 
PID Proportional – Integral – 
Derivative 
Bộ điều khiển tỉ lệ - tích phân – vi 
phân 
PLC Programmable logic control Bộ điều khiển khả trình 
PWM Pulse Width modulation Phương pháp điều chế độ rộng xung 
SISO Single input single output Hệ thống một ngõ vào một ngõ ra 
SYN Synchronous Đồng bộ 
RTS Request to send Yêu cầu để gửi 
RTT Round trip time Thời gian lặp vòng 
TCP Transmission Control 
vii 
Protocol 
UART Universal asynchronous 
receiver transmitter 
UDP User Datagram Protocol Giao thức dữ liệu người dùng 
UWB Ultra-wideband Công nghệ radio băng thông siêu 
rộng 
WIFI Wireless fidelity Tín hiệu truyền không dây 
viii 
DANH MỤC CÁC ĐƠN VỊ ĐO LƯỜNG 
Khối lượng kilogram kg 
Chiều dài meter, millimeter m, mm 
Thời gian second, millisecond s, ms 
Vận tốc meter per second, round per minute m/s, rpm 
Tốc độ truyền bit per second bps 
Công suất Watt W 
Độ phân giải pulse per  ... ]])*sampling_time 
 else: 
 xi = xi_vector[:,[-2,-1]] - (varsigma + varsigma_dot) * 
sampling_time 
 xi_vector = np.append(xi_vector, xi, axis=1) 
 #Control input 
 u = np.dot(Theta_vector[:,[-2,-1]].T,Zc) 
 u_vector = np.append(u_vector,u,axis=1) 
 #Calculate Delta_u 
 if (len(u_vector)-2-p) >= 0: 
 delta_u = u_vector[:,[-1]] - u_vector[:,[-2-p]] 
 else: 
 delta_u = u_vector[:,[-1]] 
 delta_u_vector = np.append(delta_u_vector,delta_u, axis=1) 
 #----------------------------------------------------------- 
 txt_time_total.set(t_time_vector[-1]) 
 xs.append(xc) 
 ys.append(yc) 
 #Send to Broker 
 client.publish("ncsntt/command_v_a_l", u.item(0)) 
 client.publish("ncsntt/command_v_a_r", u.item(1)) 
 if start_flag == 1: 
 threading.Timer(sampling_time, controller).start() 
def Start_button(): 
 global start_flag 
 start_flag = 1 
 controller() 
216 
def Stop_button(): 
 global start_flag, t_time_vector, z_m_vector, z_d_vector 
 start_flag = 0 
 client.disconnect() 
 plt.figure(2) 
 plt.plot(t_time_vector, z_m_vector[0,:], '-b',label='z_m(1)') 
 plt.plot(t_time_vector, z_d_vector[0,:], '--r', label='z_d(1)') 
 plt.plot(t_time_vector, z_vector[0, :], '-.k', label='z_d(1)') 
 plt.xlabel('Thời gian (s)') 
 plt.ylabel('Đáp ứng động lực học') 
 plt.grid(color='k', linestyle='--', linewidth=1) 
 plt.legend(framealpha=1, frameon=True) 
 plt.figure(3) 
 plt.plot(t_time_vector, z_m_vector[1,:], '-b',label='z_m(2)') 
 plt.plot(t_time_vector, z_d_vector[1,:], '--r', label='z_d(2)') 
 plt.plot(t_time_vector, z_vector[1, :], '-.k', label='z_d(2)') 
 plt.xlabel('Thời gian (giây)') 
 plt.ylabel('Đáp ứng động lực học') 
 plt.grid(color='k', linestyle='--', linewidth=1) 
 plt.legend(framealpha=1, frameon=True) 
 plt.figure(4) 
 plt.plot(t_time_vector, xc_vector, '-b',label='x_c') 
 plt.plot(t_time_vector, xr_vector, '--r', label='x_r') 
 plt.xlabel('Thời gian (giây)') 
 plt.ylabel('Vị trí theo phương X') 
 plt.grid(color='k', linestyle='--', linewidth=1) 
 plt.legend(framealpha=1, frameon=True) 
 plt.figure(5) 
 plt.plot(t_time_vector, yc_vector, '-b',label='y_c') 
 plt.plot(t_time_vector, yr_vector, '--r', label='y_r') 
 plt.xlabel('Thời gian (giây)') 
 plt.ylabel('Vị trí theo phương Y') 
 plt.grid(color='k', linestyle='--', linewidth=1) 
 plt.legend(framealpha=1, frameon=True) 
 plt.figure(6) 
 plt.plot(t_time_vector, u_vector[0,:], '-b',label='u(1)') 
 plt.plot(t_time_vector, u_vector[1,:], '--r', label='u(2)') 
 plt.xlabel('Thời gian (giây)') 
 plt.ylabel('Tín hiệu điều khiển') 
 plt.grid(color='k', linestyle='--', linewidth=1) 
 plt.legend(framealpha=1, frameon=True) 
 plt.show() 
def update(i): 
 line.set_data(xs,ys) 
 return line, 
def MQTT_connect(): 
 global controller_start, xc, yc, theta 
 if controller_start == 0: 
 broker_address = txt_brokeraddress.get() 
 broker_port = int(txt_port.get()) 
 Output.insert(END, "connecting to broker\n") 
 client.connect(broker_address, port=broker_port, keepalive=60) 
 Output.insert(END, "Subscribing to ncsntt/xc\n") 
 client.subscribe("ncsntt/xc") 
 Output.insert(END, "Subscribing to ncsntt/yc\n") 
217 
 client.subscribe("ncsntt/yc") 
 Output.insert(END, "Subscribing to ncsntt/theta\n") 
 client.subscribe("ncsntt/theta") 
 Output.insert(END, "Subscribing to ncsntt/v\n") 
 client.subscribe("ncsntt/v") 
 Output.insert(END, "Subscribing to ncsntt/omega\n") 
 client.subscribe("ncsntt/omega") 
 pb_connect.config(text="Connecting...") 
 controller_start = 1 
 else: 
 controller_start = 0 
 pb_connect.config(text="Connect") 
 Output.delete(1.0, END) 
 client.disconnect() 
 client.loop_start() 
# ===================================================# 
def on_message(client, userdata, message): 
 global count, controller_start, xc, yc, theta, xs, ys, v, omega 
 msg = str(message.payload) 
 Input_txt.insert(END, message.topic + " = " + msg + "\n") 
 value = float(message.payload) 
 if message.topic == "ncsntt/xc": 
 xc = round(value, 3) 
 txt_xc.set(xc) 
 if message.topic == "ncsntt/yc": 
 yc = round(value, 3) 
 txt_yc.set(yc) 
 if message.topic == "ncsntt/theta": 
 theta = round(value, 3) 
 txt_theta.set(theta) 
 if message.topic == "ncsntt/v": 
 v = round(value, 3) 
 txt_v.set(v) 
 if message.topic == "ncsntt/omega": 
 omega = round(value, 3) 
 txt_omega.set(omega) 
 xs.append(xc) 
 ys.append(yc) 
#==========================================================================
============================================= 
window = Tk() 
window.geometry('1000x700') 
window.configure(bg='white') 
window.title('Central Controller @N. T. Trung - Source') 
window.resizable(0, 0) 
topFrame = Frame(window, width=200, height=800, background="white") 
topFrame.grid(row=0, column=0, sticky="NSEW") 
bottomFrame = Frame(window, width=1000, height=800, background="white") 
bottomFrame.grid(row=0, column=1, sticky="NSEW") 
# ROW 0 
===========================================================================
===================================== 
218 
Label(topFrame, text="Broker Address",font = ('Times', 12), 
bg='white').grid(row=0, column=0, sticky="W") 
# 
txt_brokeraddress = StringVar() 
et_brokeraddress = Entry(topFrame, textvariable=txt_brokeraddress, font = 
('Times', 12), width=20) 
et_brokeraddress.grid(row=0, column=1, sticky="NSEW", columnspan=2) 
et_brokeraddress.insert(0, "broker.mqttdashboard.com") 
# ROW 1 
===========================================================================
===================================== 
Label(topFrame, text="Port",font = ('Times', 12), bg='white').grid(row=1, 
column=0, sticky="W") 
# 
txt_port = StringVar() 
et_port = Entry(topFrame, textvariable=txt_port, font = ('Times', 12), 
width=10) 
et_port.insert(0, "1883") 
et_port.grid(row=1, column=1, sticky="NSEW") 
# 
pb_connect = Button(topFrame, text='Connect',font = ('Times', 12), 
command=MQTT_connect, width=10) 
pb_connect.grid(row=1, column=2, sticky="NSEW") 
# ROW 2 
===========================================================================
===================================== 
Output = Text(topFrame, font = ('Times', 12), bg="white", width=30, 
height=5) 
Output.grid(row=2, column=0, columnspan=3, sticky="NSEW") 
# ROW 3 
===========================================================================
===================================== 
Input_txt = Text(topFrame, font = ('Times', 12), bg="white", width=30, 
height=5) 
Input_txt.grid(row=3, column=0, columnspan=3, sticky="NSEW") 
# ROW 4 
===========================================================================
===================================== 
pb_start = Button(topFrame, text='Start',font = ('Times', 12), 
command=Start_button, width=10) 
pb_start.grid(row=4, column=0, sticky="NSEW") 
# 
pb_stop = Button(topFrame, text='Stop',font = ('Times', 12), 
command=Stop_button, width=10) 
pb_stop.grid(row=4, column=1, sticky="NSEW") 
# ROW 5 
===========================================================================
===================================== 
Label(topFrame, text="xc (m)", font = ('Times', 12), 
bg='white').grid(row=5, column=0, sticky=W) 
txt_xc = StringVar() 
Entry(topFrame, textvariable=txt_xc, font = ('Times', 12), bg='white', 
width=15).grid(row=5, column=1, columnspan=1, sticky=W) 
# ROW 6 
===========================================================================
===================================== 
Label(topFrame, text="yc (m)", font = ('Times', 12), 
bg='white').grid(row=6, column=0, sticky=W) 
txt_yc = StringVar() 
Entry(topFrame, textvariable=txt_yc, font = ('Times', 12), bg='white', 
219 
width=15).grid(row=6, column=1, columnspan=1, sticky=W) 
# ROW 7 
===========================================================================
===================================== 
Label(topFrame, text="Theta (rad)", font = ('Times', 12), 
bg='white').grid(row=7, column=0, sticky=W) 
txt_theta = StringVar() 
Entry(topFrame, textvariable=txt_theta, font = ('Times', 12), bg='white', 
width=15).grid(row=7, column=1, columnspan=1, sticky=W) 
# ROW 8 
===========================================================================
===================================== 
Label(topFrame, text="v (m/s)", font = ('Times', 12), 
bg='white').grid(row=8, column=0, sticky=W) 
txt_v = StringVar() 
Entry(topFrame, textvariable=txt_v, font = ('Times', 12), bg='white', 
width=15).grid(row=8, column=1, columnspan=1, sticky=W) 
# ROW 9 
===========================================================================
===================================== 
Label(topFrame, text="omega (rad/s)", font = ('Times', 12), 
bg='white').grid(row=9, column=0, sticky=W) 
txt_omega = StringVar() 
Entry(topFrame, textvariable=txt_omega, font = ('Times', 12), bg='white', 
width=15).grid(row=9, column=1, columnspan=1, sticky=W) 
# ROW 10 
===========================================================================
===================================== 
Label(topFrame, text="Time delay (s)", font = ('Times', 12), 
bg='white').grid(row=10, column=0, sticky=W) 
txt_time_delay = StringVar() 
time_delay = Entry(topFrame, textvariable=txt_time_delay, font = ('Times', 
12), bg='white', width=15) 
time_delay.insert(0,"1") 
time_delay.grid(row=10, column=1, columnspan=1, sticky=W) 
# ROW 11 
===========================================================================
===================================== 
Label(topFrame, text="Sampling (s)", font = ('Times', 12), 
bg='white').grid(row=11, column=0, sticky=W) 
txt_sampling = StringVar() 
sampling = Entry(topFrame, textvariable=txt_sampling, font = ('Times', 12), 
bg='white', width=15) 
sampling.insert(0,"0.1") 
sampling.grid(row=11, column=1, columnspan=1, sticky=W) 
# ROW 12 
===========================================================================
===================================== 
Label(topFrame, text="Time total (s)", font = ('Times', 12), 
bg='white').grid(row=12, column=0, sticky=W) 
txt_time_total = StringVar() 
Entry(topFrame, textvariable=txt_time_total, font = ('Times', 12), 
bg='white', width=15).grid(row=12, column=1, columnspan=1, sticky=W) 
#==========================================================================
============================================ 
Output.insert(END, "creating new instance\n") 
client = mqtt.Client() # create new instance 
client.on_message = on_message # attach function to callback 
fig = plt.figure(figsize=[7, 7]) 
220 
ax = plt.axes(xlim=(-2, 2), ylim=(-2, 2)) 
plt.xlabel('X (m)') 
plt.ylabel('Y (m)') 
plt.grid(color ='k', linestyle='--', linewidth = 1) 
line, = ax.plot(xs, ys, 'b,-') 
# Set up plot to call animate() function periodically 
graph = FigureCanvasTkAgg(fig, master=bottomFrame) 
graph.get_tk_widget().grid() 
graph.draw() 
ani = animation.FuncAnimation(fig, update, interval=1, blit=True) 
window.mainloop() 

File đính kèm:

  • pdfluan_an_he_thong_dieu_khien_robot_tu_hanh_qua_mang_trong_moi.pdf
  • pdfCac cong trinh cong bo Nguyễn Trọng Trung.pdf
  • pdfNCS Nguyen Trong Trung - Nhung luan diem moi.pdf
  • pdfTom tat luan an Nguyễn Trọng Trung.pdf