Tai - Lieu - LabVIEW - FULL

Tài liệu được sưu tầm và chia sẻ miễn phí tại ARDUINO IOT VIETNAM
https://www.facebook.com/groups/486295328966960/ 1
Contents
I. TỔNG QUAN VỀ NGÔN NGỮ LẬP TRÌNH LABVIEW.......................................... 5
1.1. LabVIEW là gì? ..................................................................................................... 5
1.2. Vai trò của LabVIEW ............................................................................................ 5
1.3. Các chức năng chính của LabVIEW ...................................................................... 5
1.4. Phần mềm nhúng vào LabVIEW ........................................................................... 6
1.5. Các giao thức kết nối .............................................................................................. 6
1.6. Các Module và bộ công cụ LabVIEW ................................................................... 7
1.6.1. Các module LabVIEW .................................................................................... 7
1.6.2. Các bộ công cụ LabVIEW .............................................................................. 7
1.7.Thế mạnh của Labview. .......................................................................................... 7
1.8. LabVIEW làm việc như thế nào? ........................................................................... 8
1.9. Các thành phần của LabVIEW? ............................................................................. 8
1.10.Dòng dữ liệu trong LabVIEW. ............................................................................ 12
1.11. Thuật toán. .......................................................................................................... 13
II. Các công cụ hỗ trợ lập trình ....................................................................................... 15
2.1. Tools Palette ......................................................................................................... 15
2.2. Bảng điều khiển (Controls Palette) ...................................................................... 16
2.2.1.Numeric: ......................................................................................................... 17
2.2.2.Boolean:.......................................................................................................... 18
2.2.3. Graph: Bao gồm Graph 2D, Graph 3D ......................................................... 19
2.3. Bảng các hàm chức năng (Function palette) ........................................................ 20
2.3.1. Hàm cấu trúc - Structures Function: ............................................................. 21
2.3.2. Hàm mảng – Function Array: ....................................................................... 27
2.3.3. Hàm cụm & biến thể – Cluter & Variant: ..................................................... 30
2.3.4.Hàm số học – Numeric Function: .................................................................. 33
2.3.5. Hàm Boolean - Boolean Function:................................................................ 36
2.3.6.Hàm chuỗi – String Function: ........................................................................ 39
2.3.7. Hàm so sánh – Comparison Functions:......................................................... 42
2.3.8. Hàm Thời gian – Time function:................................................................... 46
2.3.9.Hàm Dialog & User Interface: ....................................................................... 48
2.3.10. Hàm File I/O - File I/O Function: ............................................................... 48
2.3.11. Hàm dạng sóng - Waveform: ...................................................................... 49
2.3.12. Hàm điều khiển ứng dụng- Application Control: ....................................... 50
2.3.13. Hàm đồng bộ hoá - Synchronization Function: .......................................... 51
2.3.14.Hàm đồ họa và âm thanh - Graphic & Sound Function:.............................. 51
2.3.15. Hàm phát sinh báo cáo - Report Generation Function:............................... 52
2.4. Các loại Control và Indicatior .............................................................................. 53
2.4.1. Các Control thường dùng .............................................................................. 53
2.4.2. Các dạng Indicator thường dùng. .................................................................. 54
III. Kiểu dữ liệu trong LabVIEW và chuyển đổi dữ liệu. ............................................... 57
IV. Vòng lặp While (While Loop), vòng lặp For (For Loop) và kỹ thuật sử dụng vòng
lặp. ................................................................................................................................... 61
4.1. Vòng lặp While (While Loop). ............................................................................ 61
4.2.Vòng lặp For (For Loop) ....................................................................................... 63
4.3.Formula Node:....................................................................................................... 64
4.4. Kỹ thuật sử dụng vòng lặp trong labview. ........................................................... 66
4.4.1. Kỹ thuật Timing cho vòng lặp trong LabVIEW. .......................................... 66
4.4.2. Kỹ thuật sử dụng vòng lặp For trong LabVIEW. ......................................... 69
V. Mảng ........................................................................................................................... 80
5.1.Khái niệm về mảng và cách tạo mảng .................................................................. 80
5.2. Trích dữ liệu từ một mảng.................................................................................... 82
VI. Bó .............................................................................................................................. 84
VII. Việc tạo ra các VI con ............................................................................................. 87
7.1. Thế nào là một SubVI?......................................................................................... 87
7.2. Làm thế nào khai báo tham số cho một subVI? ................................................... 90
7.3.sử dụng một subVI như thế nào? .......................................................................... 92
7.4. Việc tạo các VI con từ các thành phần của một VI.............................................. 92
7.5. Việc thiết kế các giao diện VI con. ...................................................................... 93
7.6. Lưu các VI. ........................................................................................................... 93
7.7. Việc đặt tên các VI. .............................................................................................. 93
7.8.Việc lưu giữ một phiên bản trước. ........................................................................ 93
7.9. Tuỳ biến các VI. ................................................................................................... 94
VIII.THỰC HÀNH ......................................................................................................... 95
Phần 1: Các vòng lặp và chart. .................................................................................... 95
Phần 2: Mảng, giản đồ và cấu trúc Cluster ............................................................... 104
Phần 3. Cấu trúc case và chuỗi.................................................................................. 109
IX. Lập trình nâng cao trong Labview .......................................................................... 120
I. TỔNG QUAN VỀ NGÔN NGỮ LẬP TRÌNH LABVIEW
1.1. LabVIEW là gì?

- LabVIEW (Laboratory Virtual Instrument Engineering Workbench) là ngôn ngữ lập trình đồ
họa sử dụng các biểu tượng (Icon) thay cho những dòng lệnh để tạo ứng dụng.
1.2. Vai trò của LabVIEW

- Kiểm tra, đo kiểm và phân tích tín hiệu trong kỹ thuật (đo nhiệt độ, phân tích nhiệt độ trong
ngày,…).
- Thu thập dữ liệu (Data Acquisition ), (thu thập các giá trị áp suất, cường độ, dòng điện,…).
- Điều khiển các thiết bị ( điều khiển động cơ DC, điều khiển nhiệt độ trong lò …).
- Phân loại sản phẩm (dùng chương trình xử lý ảnh để phân biệt sản phẩm bị lỗi, phế phẩm,..).
- Báo cáo trong công nghiệp (thu thập, phân tích dữ liệu và báo cáo cho
người quản lý ở rất xa thông qua giao thức truyền TCP/IP trong môi trường mạng Ethernet,..).
- Giao tiếp máy tính và truyền dẫn dữ liệu qua các cổng giao tiếp ( hỗ trợ hầu hết các chuẩn
giao tiếp như USB, PCI, COM, RS-232, RS-485).
Hình 1. Phạm vi ứng dụng của LabVIEW
1.3. Các chức năng chính của LabVIEW

- Thu thập tín hiệu từ các thiết bị bên ngoài như cảm biến nhiệt độ, hình ảnh từ webcam, vận
tốc của động cơ…
- Giao tiếp với các thiết bị ngoại vi thông qua nhiều chuẩn giao tiếp như:
Ě Mô phỏng và xử lý các tín hiệu thu nhận được để phục vụ các mục đích nghiên cứu
hay mục đích của hệ thống mà người lập trình mong muốn.
Ě Xây dựng các giao diện người dùng một cách nhanh chóng và thẩm mỹ hơn nhiều lần
so với các ngôn ngữ như VB, Matlab, Visual C…
Ě Cho phép kết hợp với nhiều ngôn ngữ truyền thống như C, C++…
Ě Cho phép thực hiện các thuật toán điều khiển như PID, Logic mờ (Fuzzy Logic).
1.4. Phần mềm nhúng vào LabVIEW

- Wolfram Research Mathematica.
- Microsoft Excel.
- The MathWorks MATLAB and Simulink.
- MathSoft MathCAD.
- Electronic Workbench MultiSim.
- Texas Instruments Code Composer Studio.
- Ansoft RF circuit design software.
- Microsoft Access.
- Microsoft SQL Server.
- Oracle.
1.5. Các giao thức kết nối

- Ethernet
- CAN
- DeviceNet
- USB
- IEEE 1394
- RS-232
- GPIB
- RS-485
Hình 2. Các giao thức kết nối của LabVIEW
1.6. Các Module và bộ công cụ LabVIEW
1.6.1. Các module LabVIEW

- Để tăng cường sức mạnh và mở rộng khả năng của bộ phần mềm phát triển LabVIEW, NI
cung cấp thêm các module hỗ trợ đến nhiều loại phần cứng nhúng khác nhau:
• Module thời gian thực (LabVIEW Real-Time Module).
• Module FPGA.
• Module điều khiển giám sát và ghi dữ liệu (LabVIEW Datalogging and Supervisory Control
Module).
• Module biểu đồ trạng thái (LabVIEW Statechart Module).
• Module mô phỏng và thiết kế bộ điều khiển (LabVIEW Control Design and Simulation
Module).
• Module phát triển thị giác (NI Visioni Development Module).
• Module cho màn hình cảm ứng và PDA (LabVIEW PDA and LabVIEW Touch Panel
Module).
• LabVIEW DSP Module ( xử lý tín hiệu số ).
1.6.2. Các bộ công cụ LabVIEW

- NI cũng thêm vào LabVIEW các bộ công cụ để đem lại các tiện ích khác nhau như: tạo báo
cáo, phân tích nâng cao, thông tin liên lạc cơ sở dữ liệu, phân tích âm thanh và rung động,…
Ě Bộ công cụ kết nối cơ sở dữ liệu (LabVIEW Database Connectivity Toolkit).
Ě Bộ công cụ xử lý tín hiệu nâng cao (LabVIEW Advanced Signal Processing Toolkit).
Ě Bộ đo lường âm thanh và rung động (LabVIEW Sound and Vibration Measurement Suite).
Ě Bộ công cụ nhận dạng hệ thống (LabVIEW System Identification Toolkit).
Ě Bộ công cụ tương tác mô phỏng (LabVIEW Simulation Interface Toolkit).
Ě Bộ công cụ theo dõi thực thi thời gian thực (LabVIEW Real-Time Execution Trace Toolkit).
Ě Bộ công cụ kết nối Internet (LabVIEW Internet Toolkit).
Ě Bộ công cụ điều biến (LabVIEW Modulation Toolkit).
Ě Bộ công cụ điều khiển PID (LabVIEW PID Control Toolkit).
Ě Bộ công cụ thiết kế bộ lọc số (LabVIEW Digital Filter Design Toolkit).
1.7.Thế mạnh của Labview.

- LabView (giống như C hay Basic) là một hệ thống lập trình đa dụng với các thư viện lớn chứa
các hàm cho bất kỳ nhiệm vụ lập trình nào. Labview cũng chứa các công cụ phát triển chương trình
thông thường nên bạn có thể đặt điểm gãy (break poin). Làm sống động quá trình thực hiện (hightlight
excution) để xem dữ liệu truyền trong chương trình như thế nào và từng bước thực hiện chương trình
thế nào để gỡ rối hoặc phát triển chương trình dễ dàng hơn.
- Labview cung cấp khả năng xây dựng những chương trình cho các hệ thống khoa học kỹ
thuật,cung cấp cho bạn một ngôn ngũ lập trình linh hoạt và có tính khả thi.
- Labview cung cấp cách nhanh hơn để lập trình với các thiết bị và các hệ thống thu thập dữ
liệu. Với việc dùng Labview, bạn có thể giảm bớt thời gian phát triển hệ thống và tăng hiệu suất làm
việc. Labview cung cấp những công cụ mạnh cho việc ghép nối các thiết bị vật lý bên ngoài mà không
phải qua phần thiết kế hệ thống một cách phức tạp như trong những ngôn ngữ khác.
- Labview là ngôn ngữ lập trình đồ họa nên rất trực quan và dễ sử dụng. Labview chứa các thư
viện cho việc thu thập dữ liệu, điều khiển các thiết bị GBIB và Serial, phân tích dữ liệu, biểu diễn dữ
liệu và cất giữ dữ liệu. Với một thư viện phong phú cho các hệ thống điều khiển, Labview có thể ứng
dụng mạnh trong việc lập trình điều khiển hệ thống.
*Việc sử dụng các hàm chức năng và các VI gắn sẵn
- LabVIEW bao gồm các VI và các hàm chức năng gán sẵn để trợ giúp bạn xây dựng các ứng
dụng đặc trưng, chẳng hạn như các VI và các hàm chức năng thu nhận dữ liệu, các VI mà truy nhập
các VI khác, các VI mà giao tiếp với các ứng dụng khác... Bạn có thể sử dụng các VI như các VI con
trong một ứng dụng để rút gọn thời gian phát triển. Trước khi bạn xây dựng một VI mới, xem xét việc
tìm kiếm bảng Functions cho các VI và các hàm thời gian tương tự và việc sử dụng một VI tồn tại như
điểm bắt đầu cho một VI mới.
1.8. LabVIEW làm việc như thế nào?

- LabVIEW được biết đến như là một ngôn ngữ lập trình với khái niệm hoàn toàn khác so với
các ngôn ngữ lập trình truyền thống như ngôn ngữ C, Pascal… Bằng cách diễn đạt cú pháp thông qua
các hình ảnh trực quan trong môi trường soạn thảo có sẵn hàng ngàn thư viện, hàm và cấu trúc lập
trình, LabVIEW đã được gọi với tên khác là lập trình G (viết tắt của Graphical).
- Những chương trình LabVIEW được gọi là những thiết bị ảo (Virtual Instruments – VIs), bởi
vì hình dạng và cách hoạt động giống với những thiết bị vật lý, chẳng hạn như máy nghiệm dao động,
máy hiện sóng…
- Trong LabVIEW, bạn xây dựng giao diện người dùng bằng cách sử dụng một bộ các công cụ
và đối tượng, và cửa sổ Front panel được xem như là giao diện người dùng. Còn cửa sổ Block diagram
chứa các hàm thao tác là các biểu tượng đồ họa, nơi mà dòng dữ liệu thực thi.
1.9. Các thành phần của LabVIEW?

- LabVIEW bao gồm các thư viện của các hàm chức năng và các công cụ phát triển được thiết
kế đặc biệt dành cho thiết bị điều khiển. Các chương trình LabVIEW được gọi là những dụng cụ ảo bởi
vì sự xuất hiện và hoạt động của chúng mô phỏng các dụng cụ thực tế. Các VI có cả 2 tương tác đó là:
một tương tác giao diện người dùng, một mã nguồn tương đương, và truy nhập các tham số từ các VI
tầng cao.
- LabVIEW gồm có 3 thành phần chính đó là: bảng giao diện ( The Front Panel), sơ đồ khối
(The Block Diagram) và biểu tượng & đầu nối (The Icon - Connect).
a. Front Panel
- Bảng giao diện Front Panel là giao diện mà người sử dụng hệ thống nhìn thấy. Các VI bao
gồm một giao diện người dùng có tính tương tác mà được gọi là bảng giao diện, vì nó mô phỏng mặt
trước của một dụng cụ vật lý. Bảng giao diện có thể bao gồm các núm, các nút đẩy, các đồ thị và các
dụng cụ chỉ thị và điều khiển khác. Người dùng nhập vào dữ liệu sử dụng bàn phím và chuột rồi sau đó
quan sát các kết quả trên màn hình máy tính. Front Panel thường gồm các bộ điều khiển (control) và
các bộ chỉ thị (inducator): Control là các đối tượng đặt trên của sổ Front Panel để cung cấp dữ liệu cho
chương trình. Indicator là đối tượng đặt trên cửa sổ Front Panel dùng để hiển thị kết quả.
Hình 3. Cửa sổ Front Panel

- Trong bảng giao diện bao gồm một thanh công cụ chứa các nút lệnh và các công cụ chỉ báo
trạng thái mà người dùng sử dụng trong quá trình chạy và xử lý các VI. Nó bao gồm những tùy chọn
phông chữ và kích thước chữ…
- Control Palette của Front Panel có 2 đối tượng:
• Điều khiển: Được sử dụng để thay đổi giá trị của các biến trong khi mô phỏng.
• Các chỉ báo: Được sử dụng để hiển thị kết quả của mã trong khi mô phỏng.
Trong đó:
(1) là nút chạy chương trình
(2) nút chạy lặp
(3) nút dừng cưỡng ép chương trình
(4) nút tạm dừng
(5) text setting (màu sắc, định dạng, kích thước, phông chữ)
(6) giống điều đối tượng theo hàng dọc và ngang
(7) phân bố các đối tượng
(8) thay đổi kích thước các đối tượng
(9) lệnh bổ sung
(10) khung tìm kiếm
(11) của sổ trợ giúp
Hình 4. Cửa sổ Front Panel

b. Block Diagram
Hình 5. Cửa sổ Block Diagram
- Sơ đồ khối Block Diagram là một sơ đồ được xây dựng trên môi trường Labview, nó có thể
gồm nhiều đối tượng và các hàm chức năng khác nhau. Block Diagram là một mã nguồn đồ họa. Các
thiết bị đầu cuối chỉ mất đi sau khi loại bỏ đối tượng tương ứng trên Front Panel. Mỗi sơ đồ khối sử
dụng đồ thị biễn các chức năng để điều khiển các đối tượng trên giao diện. Các đối tượng trên giao
diện xuất hiện như biểu tượng các thiết bị trên sơ đồ khối. Kết nối điều khiển và các đầu của dụng cụ
chỉ thị tới Express VIs, VIs, và các chức năng. Dữ liệu chuyển đi thông qua dây dẫn từ các điều khiển
đến các VI và các hàm chức năng, từ các VI và các hàm chức năng đến các VI và các hàm chức năng
khác, và từ các VI và các hàm chức năng đến các dụng cụ chỉ thị. Sự di chuyển của dữ liệu thông qua
các nút trên sơ đồ khối xác định mệnh lệnh thực hiện của các VI và các hàm chức năng. Sự di chuyển
dữ liệu này được biết như lưu đồ lập trình. Cấu trúc của một Block Diagram gồm các thiết bị đầu cuối
(Timinal), nút (node) và các dây nối (Wire).
- Terminal: là các cồng mà dữ liệu truyền qua giữa Block Diagram và Front panel, và giữa các
Node trong Block Diagram. Các Terminal tồn tại dưới dạng các Icon của các Function.
- Node: là các phần tử thực thi chương trình, chúng tương tự như các chương trình con trong
các ngôn ngữ lập trình thông thường.
- Wire: là dấy nối dữ liệu giữa các node.
Hình 6. Cửa sổ Block Diagram
1.10.Dòng dữ liệu trong LabVIEW.

- Trong LabView dữ liệu được thực hiện theo mô hình dataflow(dòng dữ liệu) để chạy VI. Một
nút sơ đồ khối thực thi khi tất cả các đầu vào của nó có sẵn. Khi một nút hoàn thành thực thi, nó cung
cấp dữ liệu cho các đầu ra của nó và chuyển dữ liệu đầu ra đến nút tiếp theo trong đường dẫn dataflow
, ví dụ ở hình 1
Hình 7. Dòng dữ liệu trong Labiew
1.11. Thuật toán.

- Thuật toán là điều quan trọng nhất đối với mọi công việc, không có Thuật toán, bạn chỉ có thể
giải quyết các vấn đề đơn giản như: 1 + 1 =? hoặc một con chó và một con sư tử, cái nào nhanh hơn ?
Nhưng khi bạn gặp một vấn đề với độ phức tạp cao hơn, thuật toán sẽ giúp bạn xác định cụ thể loại
vấn đề bạn đang giải quyết, từng bước một bạn đi đến câu trả lời cuối cùng.
- Nói về Thuật toán, hãy gặp Sơ đồ khối.
Hình 8. Biểu tượng sơ đồ
Hình 9. Ví dụ về Flowchart
II. Các công cụ hỗ trợ lập trình
- Các công cụ lập trình trên Labview bao gồm các công cụ để tạo ra các thiết bị ảo(VI). Nó bao
gồm các công cụ trong bảng giao diện (Front Panel) và các công cụ trong sơ đồ khối (Block Diagram).
Việc lập trình trên Labview cần sử dụng các bản: Tools Palette, Controls Panelette, Functions Palette.
Các bản đó cung cấp các chức năng để người sử dụng có thể tạo và thay đổi trên Front Panel và Block
Diagram.
2.1. Tools Palette

- LabVIEW sử dụng một bảng Tools nổi, bảng mà bạn có thể sử dụng để soạn thảo và gỡ lỗi
các VI. Bạn sử dụng phím <Tab> tới bảng thông qua các công cụ sử dụng thông thường trên bảng
mẫu. Nếu bạn có đóng Tools palette, chọn View>>Show Tools Palette để hiển thị bảng mẫu. Tools
palette được minh hoạ như hình 1.7 dưới đây:
Hình 10. Bảng Tool Palette

Bảng 2: Chi tiết Tools Palette
Tên công cụ Biểu tượng Chức năng
Automatic Công cụ lựa chọn tự động
Selection Tool
Đặt những mục bảng mẫu Controls và Function trên bảng
Operating tool
giao diện và sơ đồ khối.
Positionting Những lựa chọn vị trí, thay đổi kích thước và lựa chọn các
tool đối tượng
Soạn thảo văn bản và tạo ra các nhãn tự do.
Labeling tool
Nối dây các đối tượng với nhau trong sơ đồ khối
Wiring tool
Object pop-up Mang lên trên một thực đơn pop-up cho một đối tượng.
menu tool
Cuộn xuyên qua cửa sổ không sử dụng thanh công cụ cuộn.
Scroll tool
Thiết đặt các điểm dừng trên các VI, các hàm chức năng,
Breakpoint tool
các vòng lặp, các chuỗi và các trường hợp.
Probe tool Tạo ra các đầu dò trên các dây
Sao chép các màu để dán tới Color tool.

Color copy tool
Thiết đặt các màu nền và màu nổi.

Color tool
2.2. Bảng điều khiển (Controls Palette)

- Bảng Controls bao gồm một đồ thị, bảng nổi mà tự động mở ra khi bạn khởi động LabVIEW.
Bạn sử dụng bảng này để đặt các điều khiển và các dụng cụ chỉ thị trên bảng giao diện của một VI.
Mỗi biểu tượng lớp trên chứa đựng các bảng mẫu con. Nếu bảng Controls không xuất hiện, bạn có thể
mở bảng bằng cách lựa chọn View>>Show Controls Palette từ menu của bảng giao diện. Bạn cũng có
thể bật lên trên một vùng mở trong bảng giao diện để truy nhập một sự sao chép tạm thời của bảng
Controls. Sự minh hoạ sau đây hiển thị lớp đầu tiên của bảng Controls.
Hình 11. Bảng mẫu Controls
2.2.1.Numeric:
- Các điều khiển và dụng cụ chỉ thị số ( Numeric Controls and Indicator ). Ta dùng điều khiển
số để nhập các đại lượng số, trong khi đó những dụng cụ chỉ thị số thì hiển thị các đại lượng số. Hai
đối tượng số được sử dụng thông dụng nhất đó là digital control - điều khiển số và digital indicator –
chỉ thị số.
Hình 12. Bảng điều khiển và chỉ thị số
2.2.2.Boolean:
- Các điều khiển và dụng cụ chỉ thị kiểu logic (Boolean Controls and Indicator ). Ta sử dụng
điều khiển và dụng cụ chỉ thị kiểu logic cho việc nhập và hiển thị các giá trị kiểu Bool (đúng/sai-
True/False). Các đối tượng đại số Bool mô phỏng các chuyển mạch - công tắc, các nút bấm, đèn LED.
Các đối tượng đại số Bool được sử dụng thông dụng nhất là vertical toggle switch – công tắc đảo chiều
thẳng đứng và round LED - đèn LED xung quanh.
Hình 13. Bảng điều khiển và chỉ thị logic.
2.2.3. Graph: Bao gồm Graph 2D, Graph 3D

- Waveform graph : Dùng để biểu diễn những hàm đơn trị có dạng y = f (x), với những khoảng
chia ngang nhau trên các trục.
- XY graph : Dùng để biểu diễn các hàm đa trị như đường tròn hay dạng sóng thay đổi theo
thời gian.
Hình 14. Bảng Graph
- Ngoài ra, LabVIEW con rất nhiều thư viện trong bảng mẫu Control như: System, Classic,
Express, Control Design & Simulation…Trong đó có hỗ trợ rất nhiều hàm với chức năng khác nhau.
Việc sử dụng các hàm trong từng thư viện hết sức linh hoạt và tùy thuộc vào mục đích sử dụng và yêu
cầu từng bài toán.
2.3. Bảng các hàm chức năng (Function palette)

- Bảng Function bao gồm một bảng đồ thị, bảng nổi mà tự động mở ra khi bạn chuyển tới sơ đồ
khối. Bạn sử dụng bảng này để đặt các nút (hằng số, dụng cụ chỉ thị, các VI và …) trên sơ đồ khối một
VI. Mỗi biểu tượng lớp trên chứa đựng các bảng mẫu con. Nếu bảng Function không xuất hiện rõ ràng,
bạn có thể chọn View>>Show Function Palette từ menu của sơ đồ khối để hiển thị nó. Bạn cũng có thể
mở ra trên một vùng mở trong sơ đồ khối để truy nhập một một sự sao chép tạm thời của bảng
Functions. Lớp trên của bảng Functions được minh hoạ như hình sau đây:
Hình 15. Bảng Functions
- Việc khai thác thế mạnh của LabVIEW trên mỗi lĩnh vực phụ thuộc rất nhiều vào khả năng
khai thác thư viện hàm của LabVIEW. Thư viện hàm của LabVIEW được hình tượng hoá trên bảng
Funtion. Người sử dụng dễ dàng truy cập hàm cần dùng bằng cách kích chuột vào biểu tượng trên
bảng.
2.3.1. Hàm cấu trúc - Structures Function:

- Bao gồm vòng lặp For, While, cấu trúc Case, Sequence, các biến toàn cục và cục bộ. Đường
dẫn truy cập Function >>Structures. Biểu tượng của hàm Structures:
Hình 16. Hàm cấu trúc- Structures Function.
- Giống như bạn có thể thấy, chúng tôi chủ yếu sẽ làm việc với For Loop, While Loop, Nút
công thức. Nếu bạn đã có một số kinh nghiệm trong lập trình ngôn ngữ, sau đó các vòng lặp xây dựng
sẽ không khó để đối phó với.
While Loop:
- Lặp lại những gì nằm bên trong nó cho đến khi thiết bị đầu cuối có điều kiện nhận được một
giá trị Boolean cụ thể. Theo mặc định, nếu thiết bị đầu cuối có điều kiện nhận được một TRUE (Giá trị
Boolean) lặp lại dừng. Tuy nhiên, điều kiện này có thể là thay đổi bằng cách nhấp chuột phải vào nó và
thay đổi hành vi tiếp tục từ dừng lại nếu đúng để tiếp tục nếu đúng.
Hình 17. While Loop [1]
For Loop:
- For Loop và While Loop là hai lệnh cần thiết trong mọi chương trình ngôn ngữ. Sự khác biệt
chính giữa hai cái này là bởi cái sau số lần lặp được giới hạn ở số được xác định trước (N). Lặp lại (i)
terminal cung cấp số lần lặp hiện tại của vòng lặp, dao động từ 0 đến n-1.
Hình 18. For Loop [1]

Formula Node:
- Nút này tính toán các công thức toán học. Nhiều công thức toán học chẳng hạn như sin, asin,
cos, acos, giá trị tuyệt đối và vv có thể được sử dụng với điều này nút.
Hình 19. Nút công thức [1]

Bảng 3: Công thức toán học được sử dụng trong Nút công thức [1]
Tương ứng chức năng
Chức năng(Function) Sự miêu tả
LabVIEW
abs(x) Giá trị tuyệt đối Trả về giá trị tuyệt đối của x.
Làm tròn x đến số nguyên cao hơn tiếp
ceil(x) Vòng hướng + Vô cực
theo (nhỏ nhất số nguyên x).
Tính cosin của x, trong đó x nằm trong
cos(x) Cô sin
radian.
Tính toán cotangent của x (1 / tan (x)),
cot(x) Cotangent
Trong đó x là radian.
exp(x) số mũ Tính giá trị của e tăng lên x quyền lực.
Cắt x đến số nguyên thấp hơn tiếp theo
floor(x Làm tròn
(lớn nhất số nguyên x).
int(x) Vòng tới gần nhất Làm tròn x đến số nguyên gần nhất.
intrz(x) Làm tròn x đến số nguyên gần nhất giữa
-
x và số không.
Tính toán logarit tự nhiên của x (đến các
ln(x) Logarit tự nhiên
cơ sở của e).
lnp1(x) Logarit tự nhiên (Luận +1) Tính toán logarit tự nhiên của (x + 1).
Tính toán logarit của x (với cơ sở của
log(x) Cơ sở logarit 10
10).
So sánh x và y và trả về giá trị lớn hơn
max(x,y) Lớn nhất nhỏ nhất
giá trị.
So sánh x và y và trả về giá trị nhỏ hơn
min(x,y) Lớn nhất nhỏ nhất
giá trị.
Tính phần còn lại của x / y, khi thương
mod(x,y) Quotient & phần còn lại
số được làm tròn về phía tích hợp.
pow(x,y) Sức mạnh của X Tính x tăng lên sức mạnh y.
Tạo một số dấu phẩy động giữa 0 và 1
rand( ) Số ngẫu nhiên (0 - 1)
độc quyền.
Tính phần còn lại của x / y, khi thương
rem(x,y) Quotient & phần còn lại số được làm tròn đến số nguyên gần
nhất.
Trả về 1 nếu x lớn hơn 0, trả về 0 nếu x
sign(x) Ký tên bằng 0 và trả về chương trình1 nếu x
nhỏ hơn hơn 0.
Tính sin của x, trong đó x nằm trong
sin(x) Sin
radian.
Trả về kích thước của kích thước di
sizeOfDim(ary,di) -
được chỉ định cho mảng ary.
sqrt(x)
Căn bậc hai Tính căn bậc hai của x.
Tính tiếp tuyến của x, trong đó x nằm

tan(x) Tiếp tuyến
trong radian.
Flat Sequence(Trình tự phẳng):

- Bao gồm một hoặc nhiều chương trình con hoặc khung, thực hiện tuần tự. Sử dụng cấu trúc
Chuỗi phẳng để đảm bảo rằng một chương trình con thực thi trước hoặc sau một chương trình con
khác. Luồng dữ liệu cho cấu trúc Chuỗi phẳng khác với luồng dữ liệu khác cấu trúc. Các khung trong
cấu trúc Chuỗi phẳng thực hiện từ trái sang phải và khi tất cả các giá trị dữ liệu được nối với một
khung có sẵn. Dữ liệu để lại mỗi khung như khung kết thúc thực hiện. Điều này có nghĩa là đầu vào
của một khung có thể phụ thuộc vào đầu ra của khung khác. [2]
Hình 20. Flat Sequence (Chuỗi phẳng)
Case Structure(Cấu trúc trường hợp):
- Cấu trúc điều kiện, nơi bạn sẽ nhận được điều kiện đầu vào là TRUE hoặc FALSE và bên
trong cấu trúc, bạn sẽ thực hiện một số mã xử lý hoặc cảnh báo.
Hình 21. Cấu trúc trường hợp

Feedback Nodes và Shift Registers(Nút phản hồi và đăng ký thay đổi):
- Đây là hai phần tử bộ nhớ lưu dữ liệu giữa các chu kỳ tiếp theo của While Loop hoặc For
Loop. [3] Chúng được sử dụng trong trường hợp dữ liệu của thiết bị đầu cuối hiện tại phụ thuộc vào dữ
liệu trước đó.
Feedback Nodes và Shift Registers gần như giống nhau.
Hình 22. Nút phản hồi và thanh ghi Shift Registers
2.3.2. Hàm mảng – Function Array:

- Sử dụng để tạo ra và điều khiển các mảng. Đường dẫn truy cập: Function>>Array. Biểu tượng
của hàm:
Hình 23. Hàm mảng – Function Array

Bảng 4 Chi tiết về Array Palette [2]
Palette Object(Bảng Sự miêu tả
màu đối tượng)
Sử dụng hằng này để cung cấp một giá trị mảng
Array Constant
không đổi cho khối sơ đồ.
Trả về giá trị tối đa và tối thiểu được tìm thấy trong
Array Max & Min
mảng, cùng với các chỉ số cho từng giá trị.
Array Size Trả về số lượng phần tử trong mỗi chiều của mảng.
Trả về một phần của mảng bắt đầu từ chỉ mục và
Array Subset
chứa độ dài các yếu tố.
Chuyển đổi một mảng 1D thành một cụm các phần tử
cùng loại như các phần tử mảng. Nhấp chuột phải
Array To Cluster
vào chức năng và chọn Cluster Kích thước từ menu
phím tắt để đặt số lượng phần tử trong cụm.
Chuyển đổi một mảng thành một ma trận các phần tử
cùng loại với các phần tử mảng. Nối dữ liệu vào đầu
Array To Matrix
vào Real 2D Array để xác định thể hiện đa hình để sử
dụng hoặc chọn thủ công.
Nối nhiều mảng và nối các phần tử vào một mảng n
Build Array
chiều.
Chuyển đổi một cụm các phần tử có cùng kiểu dữ
Cluster To Array
liệu thành mảng 1Dcủa các yếu tố cùng loại dữ liệu.
Chia các phần tử của mảng thành các mảng đầu ra,
đặt các yếu tố vào đầu ra liên tiếp. Hàm này giảm bất
Decimate 1D Array
kỳ các phần tử gây ra các mảng đầu ra có độ dài khác
nhau.
Xóa một phần tử hoặc phân đoạn khỏi mảng chiều
dài n-dim các yếu tố bắt đầu từ chỉ số. Trả về mảng
Delete From Array
đã chỉnh sửa trong mảng w / tập hợp con đã bị xóa và
phần tử hoặc phần tử bị xóa trong phần bị xóa phần.
Trả về phần tử hoặc phân đoạn của mảng n chiều tại
Index Array
chỉ mục.
Initialize Tạo một mảng n chiều trong đó mọi phần tử là
Array khởi tạo giá trị của phần tử.
Insert Into Chèn một phần tử hoặc phân đoạn vào mảng n-dim
Array tại điểm bạn chỉ định trong chỉ mục.
Interleave Xen kẽ các yếu tố tương ứng từ các mảng đầu vào
1D Arrays thành một mảng đầu ra duy nhất.
Tuyến tính nội suy một giá trị y thập phân từ một
Interpolate
mảng số hoặc các điểm sử dụng chỉ số phân số hoặc
1D Array
giá trị x.
Chuyển đổi một ma trận các phần tử thành một mảng
Matrix To các phần tử giống nhau loại dữ liệu. Nối dữ liệu vào
Array đầu vào Real Matrix để xác định Ví dụ đa hình để sử
dụng hoặc chọn thủ công.
Replace
Thay thế một phần tử hoặc phân đoạn trong một
Array
mảng tại điểm bạn chỉ định trong chỉ mục.
Subset
Reshape Thay đổi kích thước của một mảng theo các giá trị
Array củakích thước kích thước 0..m-1.
Reverse 1D Đảo ngược thứ tự của các phần tử trong mảng, trong
Array đó mảng là bất kỳ kiểu.
Rotate 1D Xoay các phần tử của mảng số lượng vị trí và trong
Array hướng được chỉ định bởi n.
Tìm kiếm một phần tử trong mảng 1D bắt đầu từ chỉ
mục bắt đầu. Bởi vì tìm kiếm là tuyến tính, bạn
Search 1D
không cần phải sắp xếp mảng trước gọi chức năng
Array
này. LabVIEW ngừng tìm kiếm ngay khi yếu tố được
tìm thấy.
Trả về một phiên bản được sắp xếp của mảng với các
phần tử được sắp xếp trong thứ tự tăng dần. Nếu
mảng là một mảng của cụm, hàm sắp xếp các yếu tố
Sort 1D
bằng cách so sánh các yếu tố đầu tiên. Nếu các yếu tố
Array
đầu tiên khớp, hàm so sánh thứ hai và tiếp theo các
yếu tố. Cửa sổ kết nối hiển thị các loại dữ liệu mặc
định cho chức năng đa hình này.
Split 1D Chia mảng tại chỉ mục và trả về hai phần với
Array yếu tố của chỉ số ở đầu phân đoạn thứ hai.
Nội suy các điểm trong mảng 1D đại diện cho một
2D không đồ thị giảm dần. Hàm này so sánh ngưỡng
y với các giá trị trong mảng số hoặc điểm bắt đầu từ
Threshold
chỉ mục bắt đầu cho đến khi nó tìm thấy một cặp
1D Array
phần tử liên tiếp sao cho ngưỡng y là lớn hơn hoặc
bằng giá trị của phần tử đầu tiên và nhỏ hơn hoặc
bằng giá trị của phần tử thứ hai.
Transpose Sắp xếp lại các phần tử của mảng 2D sao cho mảng
2D Array 2D [i, j] trở thành mảng chuyển [j, i].
2.3.3. Hàm cụm & biến thể – Cluter & Variant:

- Sử dụng hàm này để tạo ra và điều khiển các cụm, chuyển đổi dữ liệu LabVIEW từ một
khuôn dạng bạn có thể thao tác độc lập kiểu dữ liệu, thêm những thuộc tính tới dữ liệu, và chuyển đổi
dữ liệu biến thể tới dữ liệu LabVIEW. Đường dẫn truy cập: Function>>Cluter Variant. Biểu tượng của
hàm:
Hình 24. Hàm cụm & biến thể – Cluter & Variant
Bảng 5 Chi tiết về bảng cụm [2]
Palette Object(Bảng
Sự miêu tả
Chuyển đổi một mảng 1D thành một cụm các
Array To
phần tử cùng loại như các phần tử mảng. Nhấp
Cluster
chuột phải vào chức năng và chọn Cluster Kích
thước từ menu phím tắt để đặt số lượng phần tử
trong cụm.
Build Cluster Gói từng phần tử đầu vào thành một cụm và tập
Array hợp tất cả cụm phần tử thành một mảng của cụm.
Bundle Lắp ráp một cụm từ các yếu tố cá nhân.
Thay thế một hoặc nhiều thành phần cụm. Hàm
Bundle By này dùng để chỉ các yếu tố cụm theo tên thay vì
Name theo vị trí của chúng trong
cụm.
Gọi việc thực hiện tổ tiên gần nhất của một
phương thức lớp. Bạn chỉ có thể sử dụng nút
Phương thức cha mẹ gọi trên khối sơ đồ của một
Call Parent
thành viên VI thuộc về một lớp kế thừa VI thành
Method
viên từ một lớp tổ tiên. Thành viên VI phải là
thành viên điều phối VI năng động và có cùng tên
là thành viên tổ tiên VI.
Cluster Sử dụng hằng số này để cung cấp một giá trị cụm
Constant không đổi cho khối sơ đồ.
Chuyển đổi một cụm các phần tử có cùng kiểu dữ
Cluster To
liệu thành 1D mảng các phần tử của cùng một
Array
loại dữ liệu.
Trả về dữ liệu lớp cho lớp có đường dẫn bạn nối
tới đầu vào đường dẫn lớp. Nếu lớp không có
trong bộ nhớ, LabVIEW cố gắng tải nó từ
đĩa. Nếu bất kỳ phụ thuộc bị thiếu, LabVIEW tìm
Get LV Class
kiếm các phụ thuộc còn thiếu. Nếu LabVIEW
Default Value
không thể tìm thấy sự phụ thuộc, LabVIEW giả
định sự phụ thuộc bị thiếu và không nhắc người
dùng duyệt đến cần thiết
tập tin.
Get LV Class Trả về dữ liệu lớp cho lớp có tên bạn nối với nhập
Default Value tên lớp. Nếu lớp không có trong bộ nhớ hoặc bị
By Name hỏng, LabVIEW trả về một lỗi.
Get LV Class
Trả về tên của lớp của đối tượng.
Name
Get LV Class
Trả về đường dẫn đến lớp của đối tượng.
Path
Index & Lập chỉ mục một tập hợp các mảng và tạo một
Bundle mảng cụm trong đó phần tử thứ i chứa phần tử
Cluster Array thứ i của mỗi mảng đầu vào.
Đối tượng LabVIEW là kiểu dữ liệu tổ tiên chung
cho tất cả Các lớp LabVIEW. Bạn có thể sử dụng
LV Object
Đối tượng LabVIEW để tạo các phương thức
Constant
chung có thể xử lý tất cả các kiểu dữ liệu của lớp
LabVIEW.
Kiểm tra trong thời gian chạy xem đối tượng
trong có cùng lớp với, hoặc là một lớp con của,
đối tượng đích. Sử dụng chức năng này trên sơ đồ
Preserve Run khối của một SubVI khi bạn muốn đảm bảo rằng
Time Class LabVIEW hạ thấp lớp LabVIEW đầu ra của nút
subVI cho cùng loại lớp với LabVIEW
đầu vào lớp khi subVI nhận được một lớp con của
dự kiến kiểu đầu vào.
Đánh máy một tham chiếu, chẳng hạn như điều
To More
khiển hoặc định nghĩa kiểu, cho một lớp chung
Generic Class
hơn trong hệ thống phân cấp thừa kế.
Đánh máy một tham chiếu, chẳng hạn như điều
To More
khiển hoặc định nghĩa kiểu, cho một lớp cụ thể
Specific Class
hơn trong hệ thống phân cấp thừa kế.
Unbundle Chia một cụm thành từng yếu tố riêng lẻ của nó.
Unbundle By
Trả về các thành phần cụm có tên bạn chỉ định.
Name
2.3.4.Hàm số học – Numeric Function:
- Sử dụng hàm này để tạo và thực hiện những thao tác số học, lượng giác, Lôgarit, số phức toán
học trong các số và chuyển đổi những số từ một kiểu dữ liệu này sang một kiểu dữ liệu khác. Đường
dẫn truy cập: Function>>Numeric. Biểu tượng của hàm:
Hình 25. Hàm số học – Numeric Function

- Sử dụng các hàm Express Numeric để tạo và thực hiện số học và các phép toán phức tạp trên
các số và để chuyển đổi các số từ một loại dữ liệu khác.
Bảng 6: Chi tiết về Bảng số [1]
Palette
Object(Bảng màu Trình bày đồ họa Sự miêu tả
đối tượng)
Absolute Value Trả về giá trị tuyệt đối của đầu vào.
Add Tính tổng các đầu vào.
Add Array
Trả về tổng của các phần tử trong mảng số.
Elements
Thực hiện số học trên một hoặc nhiều đầu vào số,
mảng, cụm hoặc Boolean. Để chọn thao tác (cộng,
nhân, AND, OR hoặc XOR), bấm chuột phải vào
Compound
chức năng và chọn thay đổi chế độ từ menu lối tắt.
Arithmetic
Khi bạn chọn chức năng này từ bảng số, chế độ mặc
định là Cộng (+). Khi bạn chọn chức năng này từ
bảng Boolean chế độ mặc định là OR.
Sử dụng hằng số DBL chuyển giá trị số dấu phẩy
DBL Numberic động, chính xác kép cho sơ đồ khối. Đặt giá trị này
Constant bằng cách nhấp vào bên trong hằng số bằng công cụ
điều hành và nhập giá trị.
Decrement Trừ 1 từ giá trị đầu vào.
Divide Tính thương số của đầu vào.
Sử dụng hằng số liệt kê để tạo danh sách nhãn chuỗi

Enum Constant có giá trị nguyên tương ứng mà bạn có thể chọn
trên sơ đồ khối.
Sử dụng nút biểu thức cho các biểu thức có chứa
một biến. Các hàm tích hợp sau được phép trong
các công thức: abs, acos, acosh, asin, asinh, atan,
Expression Node atanh, ceil, cos, cosh, cot, csc, exp, expm1, floor,
getexp, getman, int, intrz, ln, lnpl, log, log2, max,
min, mod, rand, rem, sec, sign, sin, sinc, sinh,
sizeOfDim, sqrt, tan, tanh.
Increment Thêm 1 vào giá trị đầu vào.
Biểu thị lỗi làm tròn số cho một số điểm nổi với độ
chính xác cho trước. Sử dụng hằng số epsilon của
Machine Epsilon
máy để so sánh xem hai số dấu phẩy động có tương
đương hay không.
Multiply Trả về tích giá trị đầu vào.
Multiply Array Trả về sản phẩm của tất cả các phần tử trong mảng
Elements số. Nếu mảng số là một mảng trống, hàm trả về giá
trị là 1. Nếu mảng số chỉ chứa một phần tử, hàm sẽ
trả về phần tử đó.
Negate Phủ định giá trị đầu vào.
Sử dụng hằng số để truyền giá trị số cho sơ đồ khối.

Numeric Constant Đặt giá trị này bằng cách nhấp vào bên trong hằng
số bằng công cụ điều hành và nhập giá trị.
Quotint &
Tính thương số nguyên và phần còn lại của đầu vào.
Remainder
Tạo độ chính xác kép, điểm nổi số từ 0 đến 1. Số
Random Number
được tạo ra lớn hơn hoặc bằng 0, nhưng nhỏ hơn 1.
(0-1)
Phân phố đồng đều.
Reciprocal Chia l cho giá trị đầu vào.
Sử dụng hằng số vòng để tạo danh sách các cặp giá

Ring Constant trị bạn có thể chọn trên sơ đồ khối. Mỗi cặp giá trị
bao gồm một giá trị số và nhãn chuỗi tương ứng.
Làm tròn số đầu vào cho số nguyên gần nhất. Nếu
Round to Nearest giá trị của đầu vào nằm giữa hai số nguyên, hàm sẽ
lấy lại số nguyên chẵn gần nhất.
Round Toward -
Cắt đầu vào số nguyên thấp nhất.
Infinity
Round Toward
Làm tròn đầu vào cho số nguyên cao nhất tiếp theo.
+Infinity
Scale By Power Of
Bội số x bằng 2 được nâng lên thành lũy thừa của n.
2
Sign Trả về dấu của số.
Square Tính bình phương của giá trị đầu vào.
Square Root Tính căn bậc 2 của giá tri đầu vào.
Subtract Tính toán sự khác biệt của các yếu tố đầu vào.
2.3.5. Hàm Boolean - Boolean Function:
- Chứa các hàm logic như: and, or, xor, nor và các hàm logic phức tạp khác. Đường dẫn truy
cập: Function>>Boolean.
Biểu tượng của hàm Boolean:
Hình 26. Hàm Boolean

Bảng 7: Chi tiết về Boolean Palette [1]
Palette
Object(Bảng Trình bày đồ họa Sự miêu tả
Tính toán logic AND của các đầu vào. Cả hai đầu
vào phải là giá trị Boolean, giá trị số, hoặc lỗi cụm.
And
Nếu cả 2 đầu vào là TRUE, hàm trả về là TRUE. Nếu
không hàm trả về FALSE.
Trả về TRUE nếu tất cả các phần tử trong mảng
Boolean là TRUE hoặc nếu mảng Boolean trống.
And Array
Nếu không, hàm trả về SAI. Hàm này chấp nhận một
Elements
mảng có kích thước bất kỳ nhưng chỉ trả về một giá
trị duy nhất dựa trên tất cả các giá trị trong mảng
Boolean.
Chuyển đổi một mảng Boolean thành một số nguyên
Boolean Array hoặc một số điểm cố định bằng cách giải thích mảng
To Number là biểu diễn nhị phân của số đó. Phần tử đầu tiên của
mảng tương ứng với bit có ý nghĩa nhỏ nhất trong số.
Chuyển đổi giá trị Boolean FALSE hoặc TRUE
Boolean To(0,1) thành số nguyên 16 bit với giá trị tương ứng là 0 hoặc
1.
Thực hiện số học trên một hoặc nhiều đầu vào số,
mảng, cụm hoặc Boolean. Để chọn thao tác (Thêm,
Nhân, VÀ, HOẶC hoặc XOR), bấm chuột phải vào
Compound
chức năng và chọn Thay đổi Chế độ từ menu lối tắt.
Arithmetic
Khi bạn chọn chức năng này từ bảng Số, chế độ mặc
định là Thêm. Khi bạn chọn chức năng này từ bảng
Boolean, chế độ mặc định là HOẶC.
Tính toán độc quyền logic hoặc (XOR) của các đầu
vào. Cả hai đầu vào phải là giá trị Boolean, giá trị số
Exclusive Or hoặc cụm lỗi. Nếu cả hai đầu vào là TRUE hoặc cả
hai đầu vào là FALSE, hàm sẽ trả về FALSE. Nếu
không, nó trả về ĐÚNG.
Sử dụng hằng số này để cung cấp giá trị FALSE cho
False Constant
sơ đồ khối.
Phủ định x và sau đó tính toán OR logic của y và x
phủ định. Cả hai đầu vào phải là giá trị Boolean, giá
Implies
trị số hoặc cụm lỗi. Nếu x là TRUE và y là FALSE,
hàm sẽ trả về FALSE. Nếu không, nó trả về ĐÚNG.
Tính toán phủ định logic của đầu vào. Nếu x là
Not FALSE, hàm trả về TRUE. Nếu x là TRUE, hàm trả
về SAI.
Tính toán NAND logic của các đầu vào. Cả hai đầu
vào phải là giá trị Boolean, giá trị số hoặc cụm lỗi.
Not And
Nếu cả hai đầu vào là TRUE, hàm sẽ trả về SAI. Nếu
không, nó trả về ĐÚNG.
Tính toán phủ định logic của độc quyền logic hoặc
(XOR) của các đầu vào. Cả hai đầu vào phải là giá trị
Not Exclusive Or Boolean, giá trị số hoặc cụm lỗi. Nếu cả hai đầu vào
là TRUE hoặc cả hai đầu vào là FALSE, hàm sẽ trả
về TRUE. Nếu không, nó trả về SAI.
Tính toán logic NOR của các đầu vào. Cả hai đầu
vào phải là giá trị Boolean, giá trị số hoặc cụm lỗi.
Not Or
Nếu cả hai đầu vào là FALSE, hàm sẽ trả về TRUE.
Nếu không, nó trả về SAI.
Chuyển đổi một số nguyên hoặc số điểm cố định
thành một mảng Boolean. Nếu bạn nối một số
nguyên thành số, mảng Boolean trả về một mảng
gồm 8, 16, 32 hoặc 64 phần tử, tùy thuộc vào số
Number To lượng bit trong số nguyên. Nếu bạn nối một số điểm
Boolean Array cố định thành số, kích thước của mảng mà mảng
Boolean trả về bằng với độ dài từ của số điểm cố
định. Phần tử thứ 0 của mảng tương ứng với bit có ý
nghĩa nhỏ nhất trong biểu diễn phần bù của hai số
nguyên.
Tính toán logic OR của các đầu vào. Cả hai đầu vào
phải là giá trị Boolean, giá trị số hoặc cụm lỗi. Nếu
Or
cả hai đầu vào là FALSE, hàm sẽ trả về FALSE. Nếu
không, nó trả về TRUE.
Trả về FALSE nếu tất cả các phần tử trong mảng
Boolean là FALSE hoặc nếu mảng Boolean trống.
Or Array Nếu không, hàm trả về ĐÚNG. Hàm này chấp nhận
Elements một mảng có kích thước bất kỳ nhưng chỉ trả về một
giá trị duy nhất dựa trên tất cả các giá trị trong mảng
Boolean.
Sử dụng hằng số này để cung cấp giá trị TRUE cho
True Constant
sơ đồ khối.
2.3.6.Hàm chuỗi – String Function:
- Sử dụng hàm này để liên kết hai hay nhiều chuỗi, tách một tập con của các chuỗi từ một
chuỗi, chuyển dữ liệu vào bên trong chuỗi, và định dạng một chuỗi sử dụng trong một công đoạn xử lý
từ hoặc ứng dụng bảng biểu. Đường dẫn truy cập: Function>>String. Biểu tượng của hàm:
Hình 27. Hàm chuỗi – String Function

Bảng 8: Chi tiết về Chuỗi bảng [2]
Palette
Object(Bảng màu Sự miêu tả
đối tượng)
Chuyển đổi một mảng của bất kỳ kích thước nào
Array To thành một bảng ở dạng chuỗi, chứa các tab tách các
Spreadsheet thành phần cột, một nền tảng-các hàng phân cách
String ký tự EOL phụ thuộc và cho các mảng của ba hoặc
nhiều kích thước, tiêu đề tách các trang.
Tạo một chuỗi đầu ra từ sự kết hợp của văn bản và
Build Text đầu vào tham số. Nếu đầu vào không phải là một
chuỗi, Express này VI chuyển đổi đầu vào thành
một chuỗi dựa trên cấu hình của Express VI.
Carriage
Bao gồm một chuỗi không đổi chứa giá trị CR
Return
ASCII.
Constant
Ghép chuỗi đầu vào và mảng 1D của chuỗi thành
Concatenate
một chuỗi đầu ra duy nhất. Đối với đầu vào mảng,
Strings
hàm này nối từng phần tử của mảng.
Empty String Bao gồm một chuỗi không đổi trống (độ dài bằng
Constant không).
End of Line Bao gồm một chuỗi không đổi chứa phụ thuộc vào
Constant nền tảng giá trị cuối dòng.
Format Hiển thị giá trị dấu thời gian hoặc giá trị số theo
Date/Time thời gian trong định dạng bạn chỉ định sử dụng mã
String định dạng thời gian.
Định dạng chuỗi, đường dẫn, kiểu liệt kê, dấu thời
Format Into
gian, Boolean hoặc dữ liệu số dưới dạng văn bản.
String
Line Feed Bao gồm một chuỗi không đổi chứa giá trị ASCII
Constant LF.
Tìm kiếm biểu thức chính quy trong chuỗi bắt đầu ở
offset. Nếu Hàm tìm thấy một kết quả khớp, nó chia
chuỗi thành ba chuỗi con. Một biểu thức chính quy
Match Pattern đòi hỏi một sự kết hợp cụ thể của ký tự cho khớp
mẫu. Chức năng này cung cấp cho bạn ít hơn tùy
chọn cho chuỗi phù hợp nhưng thực hiện nhanh hơn
chức năng Kết hợp biểu thức chính quy.
Tìm kiếm một biểu thức chính quy trong chuỗi đầu
vào bắt đầu tại phần bù bạn nhập. Nếu hàm tìm thấy
Match Regular
khớp, nó sẽ tách chuỗi thành ba chuỗi con và bất kỳ
Expression
số lượng phụ. Thay đổi kích thước hàm để xem bất
kỳ chuỗi con nào được tìm thấy trong chuỗi.
Normalize End Chuyển đổi kết thúc dòng của chuỗi đầu vào thành
Of Line kết thúc dòng định dạng bạn chỉ định. Nếu bạn
không chỉ định định dạng kết thúc dòng, VI này
chuyển đổi các kết thúc dòng của chuỗi thành dòng
kết thúc mà nền tảng hiện tại mong đợi. Sử dụng VI
này để thực hiện chuỗi của bạn có thể đọc được bởi
các nền tảng khác nhau hoặc bằng lệnh dòng của
nền tảng hiện tại.
Replace Chèn, xóa hoặc thay thế một chuỗi con ở phần bù
Substring bạn chỉ định trong chuỗi.
Scan From Quét chuỗi đầu vào và chuyển đổi chuỗi theo chuỗi
String định dạng.
Thay thế một hoặc tất cả các phiên bản của chuỗi
con bằng một chuỗi khác chuỗi con. Để bao gồm
Search and
nhiều dòng? đầu vào và cho phép nâng cao tìm
Replace String
kiếm biểu thức thông thường, bấm chuột phải vào
chức năng và chọn Biểu hiện thông thường.
Space Sử dụng hằng số này để cung cấp chuỗi không gian
Constant một ký tự cho sơ đồ khối.
Spreadsheet Chuyển đổi chuỗi bảng tính thành một mảng kích
String To thước và biểu diễn kiểu mảng. Hàm này hoạt động
Array cho mảng của chuỗi và mảng số.
String Sử dụng hằng này để cung cấp một chuỗi văn bản
Constant không đổi cho khối sơ đồ.
String Length Trả về độ dài số ký tự (byte) trong chuỗi.
Trả về chuỗi con của chuỗi đầu vào bắt đầu ở offset
String Subset
và chứa số lượng ký tự.
Bao gồm một chuỗi không đổi chứa ASCII HT (tab
Tab Constant
ngang) giá trị.
Chuyển đổi tất cả các ký tự chữ cái trong chuỗi
thành chữ thường nhân vật. Đánh giá tất cả các số
To Lower Case trong chuỗi dưới dạng mã ASCII cho nhân
vật. Chức năng này không ảnh hưởng đến phi chữ
cái nhân vật.
To Upper Case Chuyển đổi tất cả các ký tự chữ cái trong chuỗi
thành chữ hoa nhân vật. Đánh giá tất cả các số trong
chuỗi dưới dạng mã ASCII cho nhân vật. Chức
năng này không ảnh hưởng đến phi chữ cái nhân
vật.
Xóa tất cả khoảng trắng ASCII (dấu cách, tab, trả
Trim về vận chuyển, và linefeed) từ đầu, cuối hoặc cả hai
Whitespace đầu của chuỗi. Trim Whitespace VI không loại bỏ
byte kép nhân vật.
2.3.7. Hàm so sánh – Comparison Functions:

- Sử dụng hàm này để so sánh các giá trị đại số Bool, các chuỗi, các giá trị số, các mảng và các
cụm. Hàm so sánh xử lý các giá trị Boolean, string, numeric, array và cluster khác nhau. Bạn có thể
thay đổi phương pháp so sánh của vài hàm Comparison. Đường dẫn truy cập: Function>> Comparison.
Biểu tượng của hàm:
Hình 28. Hàm so sánh – Comparison Functions

Bảng 9: Chi tiết về Bảng so sánh [1]
Palette Object(Bảng
Trình bày đồ họa Sự miêu tả
So sánh các mục đầu vào bạn chỉ định để xác
Comparison định xem các giá trị có bằng nhau, lớn hơn,
nhỏ hơn, vv…
Trả về TRUE nếu char biểu thị một chữ số
Decimal Digit?
thập phân từ 0-9. Nếu char là một chuỗi, hàm
này sử dụng ký tự đầu tiên trong chuỗi. Nếu
char là một số, hàm này diễn giải nó là giá trị
ASCI của một ký tự. Nếu char là số dấu phẩy
động, hàm này làm tròn đến số nguyên gần
nhất. Mặt khác, hàm này trả về mảng đầu vào
FALSE.
Trả về TRUE nếu mảng đầu vào trống. Nếu
Empty Array?
không thì hàm này trả về FALSE.
Trả về TRUE nếu chuỗi/đường dẫn là một
Empty String/Path? đường dẫn trống rỗng, nếu không hàm này trả
về FALSE.
Trả về TRUE nếu x bằng 0. Nếu không hàm
Equal To 0?
này trả về FALSE.
Trả về TRUE nếu x bằng y. Mặt khác, hàm
Equal? này trả về thay đổi chế độ có thể so sánh của
hàm này.
Trả về TRUE nếu FXP bao gồm trạng thái
Fixed-Point Overflow? tràn và FXP là kết quả bị tràn. Nếu không
hàm này trả về FALSE.
Trả về TRUE nếu x lớn hơn hoặc bằng 0. Nếu
Greater Or Equal To 0?
không, hàm này trả về FALSE.
Trả về TRUE nếu x lớn hơn hoặc bằng y. Nếu
Greater Or Equal?
không, hàm này trả về FALSE.
Trả về TRUE nếu x lớn hơn 0. Nếu không,
Greater Than 0?
Trả về TRUE nếu x lớn hơn y. Nếu không,
Greater? hàm này trả về FALSE. Bạn có thể thay đổi
chế độ so sánh của chức năng này.
Trả về TRUE nếu char biểu thị một chữ số
hex từ 0-9, A đến F hoặc a đến f. Nếu char là
Hex Digit? một chuỗi, hàm này sử dụng ký tự đầu tiên
trong chuỗi. Nếu char là một số, hàm này diễn
giải nó là giá trị ASCII của 1 ký tự. Nếu char
là số dấu phẩy động, hàm này làm tròn đến số
nguyên gần nhất. Nếu không, hàm này trả về
FALSE.
Xác định xem x có nằm trong phạm vi được
chỉ định bởi giới hạn trên không và tùy ý ép
buộc giá trị nằm trong phạm vi đó. Hàm chỉ
thực hiện cưỡng chế trong chế độ so sánh các
In Range and Coerce
thành phần. Hàm này chấp nhận gia trị thời
gian nếu tất cả đầu vào là giá trị thời gian.
Bạn có thể thay đổi chế độ so sánh của chức
năng này.
Trả về TRUE nếu x nhỏ hơn hoặc bằng 0.
Less Or Equal To 0?
Nếu không hàm này trả về FALSE.
Trả về TRUE nếu x nhỏ hơn hoặc bằng y.
Less Or Equal?
Trả về TRUE nếu x nhỏ hơn 0. Nếu không
Less Than 0?
Trả về TRUE nếu x nhỏ hơn y. Nếu không
Less? hàm này trả về FALSE. Bạn có thể thay đổi
Trả về số lớp cho char. Nếu char là một chuỗi,
hàm này sử dụng ký tự đầu tiên trong chuỗi.
Lexical Class
Nếu char là một số, hàm này diễn giải nó là
giá trị ASCII của một ký tự.
So sánh x và y và trả về giá trị lớn hơn ở đầu
ra trên và giá trị nhỏ hơn ở đầu ra dưới. Hàm
này chấp nhận giá trị thời gian nếu tất cả các
đầu vào là giá trị thời gian. Nếu các đầu vào
Max &Min là các giá trị thời gian , hàm sẽ trả về thời gian
muộn hơn ở trên cùng và thời gian sớm hơn ở
phía dưới. Dây bị đứt nếu đầu vào không
cùng loại dữ liệu. Bạn có thể thay đổi chế độ
so sánh của chức năng này .
Trả về TRUE nếu số/đường dẫn/giới thiệu
Not A không phải là số(NaN), <Không phải là
Number/Path/Refnum? đường dẫn> hoặc không phải là giới thiệu.
Trả về TRUE nếu x khác 0. Nếu không hàm
Not Equal To 0?
này trả về FALSE.
Trả về TRUE nếu x không bằng y. Nếu không
Not Equal? hàm này trả về TRUE. Bạn có thể thay đổi
Trả về TRUE nếu char đại diện cho một chữ
số bát phân từ 0-7. Nếu char là một chuỗi
chức năng này sử dụng ký tự đầu tiên trong
chuỗi. Nếu char là một số, hàm này diễn giải
Octal Digit?
nó là giá trị ASCII của một ký tự. Nếu char là
số dấu phẩy động, hàm này làm tròn đến số
nguyên gần nhất. Nếu không này trả về
FALSE.
Trả về TRUE nếu char đại diện cho một ký tự
ASCII có thể in được. Nếu char là một chuỗi,
hàm này sử dụng ký tự đầu tiên trong chuỗi.
Nếu char là một số, hàm này diễn giải nó là
Printable?
giá trị ASCII của một ký tự. Nếu char là số
dấu phẩy động, hàm này làm tròn đến số
nguyên gần nhất . Nếu không, hàm trả về
FALSE.
Trả về giá trị có dây cho đầu vào t hoặc đầu
vào f, tùy thuộc vào giá trị của s. Nếu s là
Select TRUE, hàm này trả về giá trị có dây cho t.
Nếu s là FALSE, hàm này trả về giá trị có dây
cho f.
Trả về TRUE nếu char đại diện cho một ký tự
White Space? khoảng trắng, chẳng hạn như Dấu cách, Tab,
Dòng mới, Trả về vận chuyển, Nguồn cấp
biểu mẫu hoặc Tab dọc. Nếu char là một
chuỗi, hàm này sử dụng ký tự đầu tiên trong
chuỗi. Nếu char là một số, hàm này diễn giải
nó là giá trị ASCII của một ký tự. Nếu char là
số dấu phẩy động, hàm này làm tròn đến số
nguyên gần nhất. Nếu không, hàm này trả về
FALSE.
2.3.8. Hàm Thời gian – Time function:

- Xác định dòng thời gian, đo khoảng thời gian trôi hoặc trì hoãn một tiến trình trong một
khoảng thời gian xác định.
Đường dẫn truy cập: Function>> Timing. Biểu tượng của hàm Time:
Hình 29. Hàm Thời gian – Time function
Bảng 10: Chi tiết về Bảng thời gian [2]

Palette
Object(Bảng màu Sự miêu tả
đối tượng)
Chuyển đổi một cụm các giá trị thời gian thành dấu thời
Date/Times to gian được đo là số giây đã trôi qua từ 12:00 sáng, Thứ Sáu,
seconds ngày 1 tháng 1 năm 1904, Giờ quốc tế, giả sử là DST được
đặt đến 1.
Elapsed Cho biết lượng thời gian đã trôi qua kể từ khi được chỉ định
Time thời gian bắt đầu.
Hiển thị giá trị dấu thời gian hoặc giá trị số theo thời gian
Format Date/Time
trong định dạng bạn chỉ định sử dụng mã định dạng thời
String
gian.
Get Trả về dấu thời gian của thời điểm hiện tại. LabVIEW tính
Date/Time In toán dấu thời gian này sử dụng số giây trôi qua kể từ 12:00
Seconds a.m., Thứ Sáu, ngày 1 tháng 1 năm 1904, Giờ phổ quát.
Chuyển đổi giá trị dấu thời gian hoặc giá trị số thành ngày
Get và giờ chuỗi trong múi giờ được cấu hình cho máy
Date/Time tính. Chức năng diễn giải các dấu thời gian và các giá trị số
String là múi giờ- số giây độc lập đã trôi qua kể từ 12:00 sáng, thứ
Sáu, ngày 1 tháng 1 năm 1904, Giờ phổ quát.
Trả về thời gian hiện tại tương đối tính bằng giây. Sử dụng
sự khác biệt giữa hai giá trị liên tiếp để đo thời gian trôi qua
High
thời gian giữa các cuộc gọi. Sử dụng VI này để đo khoảng
Resolution
thời gian với độ phân giải cao hơn nhiều so với số lượng
Relative
bạn có thể đạt được từ Đếm số (ms) chức năng. Độ phân
Seconds
giải thời gian của VI này có thể thay đổi theo hệ điều hành
và loại CPU khác nhau.
Chuyển đổi một giá trị dấu thời gian hoặc một giá trị số
thành một cụm giá trị thời gian. Hàm này mất một phần giây
Seconds To
chính xác khi chuyển đổi dấu thời gian. Nếu bạn chuyển đổi
Date/Time
thời gian ngày rec trở lại thành một dấu thời gian, dấu thời
gian có thể không hiển thị chính xác giá trị.
Tick Count (ms) Trả về giá trị của bộ đếm thời gian mili giây.
Time Delay Chèn thời gian trễ vào cuộc gọi VI.
Time Stamp Sử dụng hằng số dấu thời gian để chuyển giá trị thời gian và
Constant ngày cho sơ đồ khối.
To Time Stamp Chuyển đổi một số thành dấu thời gian.
Chờ số mili giây đã chỉ định và trả về giá trị của bộ đếm
Wait (ms) thời gian mili giây. Đấu giá trị từ 0 đến mili giây chờ đầu
vào buộc luồng hiện tại kiểm soát năng suất của CPU.
Chờ cho đến khi giá trị của bộ đếm thời gian mili giây trở
thành bội số của bội số mili giây được chỉ định. Sử dụng
Wait Until chức năng này để đồng bộ hóa hoạt động. Bạn có thể gọi
Next ms hàm này trong một vòng lặp để kiểm soát tốc độ thực hiện
Multiple vòng lặp. Tuy nhiên, có thể là chu kỳ vòng đầu tiên có thể
ngắn. Nối giá trị 0 đến nhiều mili giây nhiều đầu vào buộc
luồng hiện tại mang lại điều khiển CPU.
2.3.9.Hàm Dialog & User Interface:

- Sử dụng hàm này để tạo ra các hộp thoại tới nhắc nhở người sử dụng với các chỉ dẫn.
- Đường dẫn truy cập: Function>> Dialog & User Interface.
- Biểu tượng của hàm:
Hình 30. Hàm Dialog & User Interface
2.3.10. Hàm File I/O - File I/O Function:

- Thực hiện các chức năng cho một tập tin như lưu, mở tập tin theo dạng nhị phân, spreadsheet,
đóng một tập tin… Ngoài ra hàm này còn chứa các chức năng mở rộng khác về lưu trữ dữ liệu. Đường
dẫn truy cập: Function >> File I/O. Biểu tượng của hàm File I/O:
Hình 31. Hàm File I/O- File I/O Function
2.3.11. Hàm dạng sóng - Waveform:

- Sử dụng hàm này để xây dựng dạng sóng mà bao gồm các giá trị dạng sóng, thay đổi thông
tin, để thiết lập và khôi phục các thành phần và thuộc tính của dạng sóng. Đường dẫn truy cập:
Function>>Waveform.
Biểu tượng của hàm là:
Hình 32. Hàm dạng sóng – Waveform
2.3.12. Hàm điều khiển ứng dụng- Application Control:

- Sử dụng hàm này để lập trình các VI điều khiển và các ứng dụng LabVIEW trên máy tính địa
phương hoặc qua một mạng. Ta có thể sử dụng các VI và các hàm chức năng này để định dạng nhiều
VI tại cùng một thời điểm. Đường dẫn truy cập: Function>> Application Control. Biểu tượng của hàm:
Hình 33. Hàm điều khiển ứng dụng- Application Control
2.3.13. Hàm đồng bộ hoá - Synchronization Function:

- Sử dụng hàm này để đồng bộ các nhiệm vụ thi hành song song và để chuyển dữ liệu giữa các
nhiệm vụ song song. Đường dẫn truy cập: Function>> Synchronization. Biểu tượng của hàm là:
Hình 34. Hàm đồng bộ hoá - Synchronization Function
2.3.14.Hàm đồ họa và âm thanh - Graphic & Sound Function:

- Sử dụng hàm này để tạo ra yêu cầu hiển thị, dữ liệu cổng vào và cổng ra từ các phai đồ hoạ và
cho chạy những âm thanh. Đường dẫn truy cập: Function>>Graphic & Sound. Biểu tượng của hàm là:
Hình 35. Hàm đồ họa và âm thanh – Graphic & Sound Function
2.3.15. Hàm phát sinh báo cáo - Report Generation Function:

- Sử dụng hàm này để tạo và điều khiển các báo cáo của các ứng dụng LabVIEW. Đường dẫn
truy cập: Function>>Report Generation. Biểu tượng của hàm là:
Hình 36. Hàm phát sinh báo cáo – Report Generation Function
2.4. Các loại Control và Indicatior
2.4.1. Các Control thường dùng

- Các control thường dùng gồm các dạng: numeric, fill slide, pointer slide, knob, dial, constant,
string, simulated signal,vv.
- Để lấy các Control, ta vào thư viện theo đường dẫn: FP> Express > Numeric Control như
Hình 3.1 và chọn Control cần lấy. Ví dụ lấy Numeric control: Right click trên cửa sổ FP, chọn
Express, chọn Numeric Control, Chọn Numeric Control và đặt ra màn hình. Tương tự đối với Slide
control và String control ta làm như trên.
Hình 37. Cách lấy Control

- Ta có thể copy nhanh các Control bằng cách nhấn Ctrl (Trên bàn phím) và kéo thả các
Control bằng chuột trái.
Hình 38. Copy nhanh bằng việc kéo thả

Bảng 11: Các Control thường dùng
Numeric
Là control dạng số.
control
Fill slide Control có dạng một thanh trượt.
Pointer
Control dạng thanh trượt có nút kéo.
slide
Knob Nút vặn.
Dial Đĩa xoay.
Hằng số, hay có thể xem là một dạng numeric control

nhưng giá trị không thay ñổi trong suốt quá trình chạy
Constant chương trình. Để tạo Constant ta lấy một Numeric
control, chuột phải lên Numeric control chọn Change to
constant.
Là 1 dòng chữ hay còn gọi là text control. Sử dụng text
String
Control này để nhập các chữ hoặc chuổi ký tự, hoặc một
control
câu văn.
- Một tín hiệu được mô phỏng sẵn trong LabVIEW có

thể dùng như một Indicator trong một số trường hợp.
Lấy Simulated signal bằng cách vào: BD> Express>
Simulated
Input> Simulated Signal. Xác lập các thông số khi bảng
signal
thông số hiện ra.
- Nối đầu ra của khối vừa lấy với một Graph bằng cách
chọn Right Click lên đầu ra, Create> Indicator.
- Thường các control được chia làm 3 dạng: Boolean, Numeric và String.
2.4.2. Các dạng Indicator thường dùng.

- Tương tự các Control, ta cũng có các Indicator như: numeric, string, slide, vv… Giữa Control
và Indicator có thể chuyển đổi qua lại nhờ vào thao tác Right Click> Change to Control hoặc Change
to Indicator.
- Để lấy các Indicator, ta vào thư viện theo đường dẫn: FP> Express > Numeric Indicator> như
hình 1.30 và chọn Control cần lấy. Ví dụ lấy Numeric control: Right click trên cửa sổ FP, chọn
Express, chọn Numeric Indicator, Chọn Numeric Indicator và đặt ra màn hình. Tương tự đối với Slide
control và String control ta làm như trên.
Hình 39. Cách lấy Indicator
Bảng 12: Tóm tắt các Indicator
Numeric
Là Indicator dạng số.
indicator
Meter Indicator có dạng đồng hồ vuông.
Gauge Indicator dạng đồng hồ tròn.
Thermometer Cột nhiệt độ.
Graduated Bar Thanh hiển thị quá trình.
Là 1 dòng chữ hay còn gọi là text Control, dùng để xuất

String
các chữ hoặc chuỗi ký tự, hoặc một câu văn.
Chart Là biểu đồ hiển thị các giá trị theo trục thời gian.
Là đồ thị thường ñược dùng ñể hiển thị các tín hiệu dạng
Graph
sóng (waveform).
Đồ thị hiển thị quan hệ giữa hai tín hiệu X và Y hoặc
XY Graph
dùng trong bài vẽ đồ thị.
Ví dụ về sử dụng Chart trình bày như hình 40

- Trong hình trên, để tạo sóng Sine, ta lấy Simulated Input theo đường dẫn: BD> Express>
Input> Simulated Input và đặt thông số như mặc định trong hình 1.32.

- Ngoài ra, một Numeric Indicator đã được sử dụng để chỉnh Amplitude (biên độ) của sóng
Sine, và một Graph Indicator để hiển thị sóng Sine.
III. Kiểu dữ liệu trong LabVIEW và chuyển đổi dữ liệu.
- LabVIEW đại diện cho các loại dữ liệu số dưới dạng số dấu phẩy động, cố định-số điểm, số
nguyên, số nguyên không dấu và số phức. Các sự khác biệt giữa các kiểu dữ liệu số là số bit chúng sử
dụng để lưu trữ dữ liệu và các giá trị dữ liệu mà chúng đại diện. [2] (Windows) LabVIEW chỉ có thể
xử lý dữ liệu trong phạm vi được hiển thị trongBảng kiểu dữ liệu số, nhưng nó có thể hiển thị ở định
dạng văn bản một phạm vi
± 9,9999999999999999E999. (Ví dụ = 10 ^ x) [2]
Bảng 13: Số phức
Độ chính xác đơn, điểm nổi (CSG) phức tạp – gọi là độ chính xác đơn, điểm nổi cho
từng phần(thực và ảo).
Độ chính xác kép, điểm nổi (CDB) phức tạp-Được gọi là độ chính xác kép, điểm nổi cho
từng phần (thực và ảo).
Độ chính xác mở rộng phức tạp, điểm nổi (CXT)- Được gọi là độ chính xác mở rộng.
Dấu phẩy động cho mỗi phần(thực và ảo).
Bảng 14: Số dấu phẩy động
Single-precision(SGL) - Các số có độ chính xác, dấu phẩy động có định dạng chính xác
đơn 32 bit của IEEE. Sử dụng các số có dấu phẩy động, chính xác đơn khi tiết kiệm bộ
nhớ là quan trọng và bạn sẽ không vượt quá phạm vi của các số.
Double-precision(DBL)- Các số có độ chính xác kép, dấu phẩy động có định dạng
chính xác kép 64 bit của IEEE. Độ chính xác kép là định dạng mặc định cho các đối
tượng số. Đối với hầu hết các tình huống, sử dụng số chính xác, số dấu phẩy động.
Extended-precision(EXT) - Khi bạn lưu các số có độ chính xác mở rộng vào đĩa,
Labview lưu trữ chúng ở định dạng 128 bit độc lập với nền tảng. Trong bộ nhớ, kích
thước và độ chính xác khác nhau tùy thuộc vào nền tảng. Chỉ sử dụng các số dấu phẩy
động, chính xác mở rộng khi cần thiết. Hiệu suất của số học chính xác mở rộng khác
nhau giữa các nền tảng.
- LabVIEW hỗ trợ cho tất cả các dạng dữ liệu. Các kiểu dữ liệu dạng Boolean, bytes, string,
array, file, text, cluster và dạng số có thể được chuyển đổi một cách dễ dàng sang các dạng cấu trúc.
- Kiểu dữ liệu là công cụ dùng để gán (ép) một numeric hay indicator vào một dãy giá trị nào
đó. Ví dụ, ta muốn một Numeric Control có giá trị (và chỉ nằm trong giá trị đó ngay cả khi người điều
khiển nhập giá trị khác) là 0-255 thì ta sẽ gán Numeric Control đó vào kiểu dữ liệu Unsigned 8 bit
(Viết tắt là U8). Muốn đổi kiểu dữ liệu của một Control, ta chọn Right Click lên Control đó> Chọn
Representation> Chọn Kiểu cần gán. Hình 42 liệt kê các kiểu dữ liệu trong LabVIEW.
Hình 42. Các kiểu dữ liệu trong LabVIEW
- Trong LabVIEW có nhiều kiểu dữ liệu khác nhau.
Bảng 14: Bảng kiểu dữ liệu số
Kiểu dữ liệu Số chữ số thập

Ký hiệu Số bit Khoảng giá trị
số phân gần đúng
số dương tối thiểu:1.40e-45

Độ chính xác
số dương tối đa:3.40e+38
đơn,dấu phẩy 32 6
số âm tối thiểu: -1.40e-45
động
số âm tối đa:-3.40e+38
Độ chính xác
kép, dấu phẩy 64 15
động
số âm tối đa:- 1.79e+308
Độ chính xác thay đổi từ 15
mở rộng, 128 đến 20 theo nền
điểm nổi tảng
số âm tối đa:- 1.19e+4932
phức tạp đơn giống như độ chính xác đơn, dấu
- chính xác, 64 6 phẩy động cho từng phần (thực
nổi - điểm và ảo)
phức tạp kép - giống như độ chính xác kép, dấu
chính xác, nổi 128 15 phẩy động cho từng phần (thực
- điểm và ảo)
phức tạp mở
Thay đổi từ 15 giống như độ chính xác mở rộng,
rộng - chính
256 đến 20 theo nền dấu phẩy động cho từng phần
xác, nổi -
tảng (thực và ảo)
điểm
64 hoặc 72
nếu bạn bao thay đổi theo cấu thay đổi theo cấu hình người
điểm cố định
gồm trạng hình người dùng dùng
thái tràn
Byte signed
8 2 -128 đến 127
integer
Word signed
16 4 -32,768 đến 32,767
integer
Long signed -2,147,483,648
32 9
integer đến2,147,483,647
Quad signed
64 18 -1e19 đến 1e19
integer
Byte
unsigned 8 2 0 đến 255
integer
Word
unsigned 16 4 0 đến 65,535
integer
Long
unsigned 32 9 0 đến 4,294,967,295
integer
Quad
unsigned 64 19 0 đến 2e19
integer
Thời gian tối thiểu: 01/01/1600
128-bit time 00:00:00
128 19
stamp Thời gian UTC tối đa:
01/01/3001 00:00:00 UTC
- Cách chuyển đổi kiểu dữ liệu: chuột phải lên đối tượng muốn chuyển đổi chọn Represention
rồi chọn kiểu dữ liệu mong muốn.
*Variables (biến).
- Trong quá trình lập trình cần thiết phải sử dụng tới các biến. Thông qua các biến, người lập
trình có thể thực hiện được việc xử lý và thay đổi dữ liệu một cách thuận lợi. Trong LabVIEW, các
biến được sử dụng dưới 2 dạng là biến toàn cục (global variables) và các biến địa phương (local
variables).
- Global variables (biến toàn cục):
• Biến toàn cục được sử dụng để thực hiện công việc truyền và lưu trữ dữ liệu giữa một vài VI.
Biến toàn cục được coi là một đối tượng trong LabVIEW. Khi ta tạo ra một biến toàn cục LabVIEW sẽ
tạo ra một “VI toàn cục” đặc biệt. Để tạo ra các biến toàn cục, ta lựa chọn chúng trên menu “Structs
and Constants function” sau đó đặt chúng lên Block Diagram. Tiếp tục cần xác định cho chúng kiểu dữ
liệu thông qua các kiểu dữ liệu đã sử dụng thông qua các Controls hoặc các Indicators. Chúng ta cần
chú ý là đối với mỗi biến toàn cục chúng ta cần phải tạo ra một VI với một tên riêng duy nhất. Đối với
các biến toàn cục chúng ta cũng cần xác định chế độ chỉ cho phép ghi hoặc chỉ cho phép đọc. Đối với
việc truy xuất vào biến toàn cục sẽ thực hiện rất nhanh chóng đối với các kiểu dữ liệu đơn giản như
Numerics và Boolean. Tuy nhiên, khi ta sử dụng biến toàn cục để lưu trữ và xử lý các dữ liệu dưới
dạng mảng (arrays), Clusters hay các sâu (string) lớn thì thời gian cũng như bộ nhớ cần thiết để xử lý
chúng lại sẽ tương đối lớn. Vì nó đòi hỏi một vài dịch vụ quản lý bộ nhớ mỗi khi các biến đó gọi tới.
Khi sử dụng các biến toàn cục cũng như các biến cục bộ thì một vấn đề có thể gặp phải là “sự tranh
chấp dữ liệu”. Biến sử dụng trong Labview không hoàn toàn giống như trong các ngôn ngữ lập trình
dòng lệnh. Việc “tranh chấp dữ liệu” xảy ra khi hai hoặc nhiều hơn các đoạn mã lệnh cùng thực hiện
song song cùng thay đổi giá trị của một biến. Đầu ra của VI phụ thuộc vào thứ tự được thực thi của các
dòng lệnh. Bởi vì nếu không có sự phụ thuộc dữ liệu giữa các biểu thức khác nhan thì sẽ không xác
định được cái nào chạy trước. Nếu sử dụng các biến toàn cục trong Vis mà được thực hiện song song,
thì ta có thể sử dụng một biến toàn cục thêm vào để xác định khi nào dữ liệu được phép thay đổi và
được đọc giá trị mới.
- Local variable (các biến địa phương):
• Biến địa phương cho phép người sử dụng đọc hoặc viết thông tin lên một trong những thiết bị
điều khiển hoặc thiết bị hiển thị trên Front Panel. Để tạo một biến địa phương, chọn Local Variable từ
bảng Structs & Constant. Khi sử dụng biến địa phương cần chú ý một số thông tin sau:
Ě Các biến địa phương bộ chỉ có tác dụng duy nhất trên các thiết bị điều khiển hoặc thiết bị hiển
thị mà cùng ở trên một lược đồ. Ta không thể sử dụng biến địa phương để truy cập tới một điều khiển
mà không cùng trên một lược đồ.
Ě Ta có thể có rất nhiều các biến địa phương cho mỗi thiết bị điều khiển hoặc thiết bị hiển thị.
Tuy nhiên điều đó có thể gây ra sự phức tạp, cho rằng điều khiển của bạn thay đổi trạng thái một cách
khó hiểu bởi vì bạn ngẫu nhiên lựa chọn sai các phần tử trong một hoặc nhiều biến địa phương
• Giống như biến toàn cục, bạn có thể sử dụng biến địa phương không có một “dòng dữ liệu”
hợp lệ khác sử dụng.
IV. Vòng lặp While (While Loop), vòng lặp For (For Loop) và
kỹ thuật sử dụng vòng lặp.
4.1. Vòng lặp While (While Loop).

- Vòng lặp while là vòng lặp có điều kiện như trong hình 43. Ý nghĩa của vòng lặp While là
cho phép chạy chương trình mãi tới khi nào nút Stop được nhấn thì mới dừng lại. Để lấy While Loop
ta vào BD> Express> Execution> While loop như trình bày trong hình 1.34.
- While Loop sẽ lặp lại chương trình được đặt trong vòng lặp này, tới khi nút Stop
(conditional terminal) nút Stop tại FP được nhấn (Lưu ý rằng nút Stop có dạng dữ liệu là
Boolean-true hoặc false).
Hình 43. Lấy While Loop tại BD
Hình 44. Tính tổng với While Loop
Xét ví dụ trong hình 44 như sau:
- Có hai phép tính cộng. Phép cộng A là cộng Numeric 1và Numeric 2 hiển thị kết quả ra
Indicator 1, phép cộng B là phép cộng Numeric 2 và Numeric 3 hiển thị kết quả ra Indicator 2. Khác
biệt duy nhất là phép cộng A đặt ngoài vòng lặp còn phép cộng B đặt trong vòng lặp. Chạy chương
trình (nhấn phím tắt Ctrl+R), sau đó thay đổi giá trị của Numeric 1, 2, 3, 4. Ta sẽ quan sát thấy phép
cộng A sẽ không có giá trị thay đổi tại Indicator 1. Còn Indicator 2 sẽ thay đổi giá trị khi bạn thay đổi
giá trị nhập vào Numeric 3 và 4. FP và BD của ví dụ này được trình bày trong hình 1.35. Ngoài ra,
trong While Loop còn có chân iteration (i) có ký hiệu ( ) là bộ đếm số lần lặp hiện tại (current loop
iteration count) (lần thực hiện đầu tiên i=0). Giá trị lớn nhất của (i) là 2,147,483,647 (231,), và giữ mãi
mãi sau đó. Nếu cần giá trị lớn hơn 2,147,483,647, dùng shift registers có miền giá trị integer lớn hơn,
hoặc sử dụng một vòng lặp For Loop trong trường hợp này.
- Ngoài ra, ta còn có thể sử dụng shift-register trong While Loop. Shift-register là một thanh
ghi hoạt động như một ô nhớ. Ta sử dụng thanh ghi này để truy cập lịch sử giá trị của một tín hiệu nào
đó, ví dụ chương trình của chúng ta đang chạy ở thời gian là 10:30am, và ta muốn xem lại giá trị của
tín hiệu đo được từ cảm biến nhiệt độ ở thời điểm 10:29am. Ngoài ra, Shift register cũng có thể dùng
để thực hiện các phép toán cộng dồn. Nói cách khác là có thể dùng Shift registers để “chuyển” giá trị
của đối tượng/tín hiệu nào đó ở vòng lặp này sang vòng lặp kế tiếp.
Hình 45. Sử dụng shift register
4.2.Vòng lặp For (For Loop)

- Cũng như While Loop, For Loop là vòng lặp mà số lần lặp lại có thể định trước bởi người lập
trình. Lấy For Loop trong thư viện như sau: BD> Express> Execution> For Loop.
- Ví dụ ta muốn chạy chương trình tính tổng A+B trong 100 lần thì sau lần lặp lại phép tính
tổng thì chương trình sẽ tự thoát (tự dừng). Như trong hình ta đã đặt số vòng lặp cần lặp lại là 100 (đặt
thông qua khối Numeric). Sau khi chạy chương trình thì Numeric 2 (đóng vai trò là Indicator chỉ ra số
vòng đã lặp được) sẽ báo số 99. Lý do là LabVIEW đếm vòng lặp đầu tiên có giá trị (i)=0.
Hình 46. For Loop
4.3.Formula Node:
- Nút này tính toán các công thức toán học. Nhiều công thức toán học chẳng hạn như sin, asin,
cos, acos, giá trị tuyệt đối,vv… có thể được sử dụng với điều này nút.
Hình 47. Nút công thức [1]

Bảng 15: Công thức toán học được sử dụng trong Nút công thức [1]
Chức năng Tương ứng Chức
Sự miêu tả
( Function ) năng LabVIEW
abs(x) Giá trị tuyệt đối Trả về giá trị tuyệt đối của x.
Làm tròn x đến số nguyên cao hơn tiếp theo (nhỏ nhất số
ceil(x) Vòng hướng + Vô cực
nguyên x).
cos(x) Cô sin Tính cosin của x, trong đó x nằm trong radian.
Tính toán cotangent của x (1 / tan (x)), Trong đó x là
cot(x) Cotangent
radian.
exp(x) số mũ Tính giá trị của e tăng lên x quyền lực.
Cắt x đến số nguyên thấp hơn tiếp theo (lớn nhất số
floor(x Làm tròn
nguyên x).
int(x) Vòng tới gần nhất Làm tròn x đến số nguyên gần nhất.
intrz(x) - Làm tròn x đến số nguyên gần nhất giữa x và số không.
ln(x) Logarit tự nhiên Tính toán logarit tự nhiên của x (đến các cơ sở của e).
lnp1(x) Logarit tự nhiên Tính toán logarit tự nhiên của (x + 1).
(Luận +1)
log(x) Cơ sở logarit 10 Tính toán logarit của x (với cơ sở của 10).
max(x,y) Lớn nhất nhỏ nhất So sánh x và y và trả về giá trị lớn hơn giá trị.
min(x,y) Lớn nhất nhỏ nhất So sánh x và y và trả về giá trị nhỏ hơn giá trị.
Quotient & phần còn Tính phần còn lại của x / y, khi thương số được làm tròn
mod(x,y)
lại về phía tích hợp.
pow(x,y) Sức mạnh của X Tính x tăng lên sức mạnh y.
rand( ) Số ngẫu nhiên (0 - 1) Tạo một số dấu phẩy động giữa 0 và 1 độc quyền.
Quotient & phần còn Tính phần còn lại của x / y, khi thương số được làm tròn
rem(x,y)
lại đến số nguyên gần nhất.
Trả về 1 nếu x lớn hơn 0, trả về 0 nếu x bằng 0 và trả về
sign(x) Ký tên
chương trình1 nếu x nhỏ hơn 0.
sin(x) Sin Tính sin của x, trong đó x nằm trong radian.
sizeOfDim Trả về kích thước của kích thước di được chỉ định cho
(ary,di) mảng ary.
sqrt(x) Căn bậc hai Tính căn bậc hai của x.
tan(x) Tiếp tuyến Tính tiếp tuyến của x, trong đó x nằm trong radian.
4.4. Kỹ thuật sử dụng vòng lặp trong labview.
4.4.1. Kỹ thuật Timing cho vòng lặp trong LabVIEW.
Hình 48.1. Timing cho vòng lặp While loop

- Các hàm thời gian trong LabVIEW rất là quan trọng và giúp chúng ta đo đếm thời gian, đồng
bộ các tác vụ và cho phép bộ vi xử lí (CPU) có những khoàng thời gian idle cần thiết cho việc thực thi
chương trình, VI và vòng lặp của bạn.
- Khái niệm vòng lặp (While loop hoặc For loop) là một trong những khái niệm cơ bản của bất
cứ ngôn ngữ lập trình nào. Nhưng có một số vấn đề liên quan đến các vòng lặp mà những người mới
lập trình LabVIEW thường không để ý hoặc vô tình mắc phải khiến cho sự hoạt động của chương trình
LabVIEW không đạt được mức tối ưu. Một trong những điểm dễ mắc phải là thiếu sử dụng các hàm
định cỡ thời gian trong các vòng lặp.
- Ví dụ: Hãy thử tạo ra hai chương trình có Block diagram sau đây rồi lần lượt chạy thử chúng.
Trong quá trình chạy thử bạn hãy kiểm tra thông tin của trình quản lí bộ vi xử lí (CPU).
Hình 48.2. Timing cho vòng lặp while loop
- Chương trình trên chỉ có một nhiệm vụ đơn giản là tạo ra một vòng lặp while và hiển thị số
vòng lặp trong quá trình thực thi. Thế nhưng với phương pháp lập trình này, vòng lặp đã không được
thực thi một cách tối ưu nên tài nguyên CPU của máy đã bị khai thác gần như là tối đa.Trong
LabVIEW, thông thường khi kết thúc một vòng lặp, nó ngay lập tức bắt đầu thực thi một vòng lặp tiếp
theo. Không có một sự ngừng trệ hay trì hoãn giữa các vòng lặp liên tục. Hay nói đúng ra là hệ thống
luôn luôn phải dò xét (polling) xem liệu đã có thể thực thi được vòng lặp tiếp theo hay chưa? Liệu đã
kết thúc vòng lặp trước hay chưa? Liệu các giá trị, các tác vụ trong vòng lặp trước đã được cập nhật,
hoàn thành.
- Điều này dẫn tới việc toàn bộ CPU phải tập trung thực thi ứng dụng của LabVIEW mà không
có thời gian và tài nguyên để thực thi các tác vụ khác, nhiều khi dẫn tới máy bị treo. Do đó đối với
những ứng dụng vẫn thường gặp của chúng ta thì ta cần phải xác định và kiểm soát tốc độ thực thi
vòng lặp của nó, mức độ tần suất thực thi của vòng lặp để CPU có những khoảng thời gian dù nhỏ
nhưng rất đáng kể nằm ở trạng thái Idle, Sleep hoặc thực thi các tác vụ khác.
Ví dụ: Nếu bạn muốn truyền dữ liệu trong một vòng lặp, bạn cần một phương pháp xác định tốc độ
(Tần số) mà dữ liệu được truyền. Hãy xác định cho vòng lặp được nghỉ trong một khoảng thời gian
nào đó. Trong những khoảng thời gian nghỉ đấy, bộ vi xử lí có thể thực thi các nhiệm vụ khác từ các
ứng dụng khác. Hãy xem cách cải thiện cho vấn đề trên như sau:
Hình 48.3. Timing cho vòng lặp while loop
- Bạn chỉ việc thêm vào vòng lặp while một hàm Wait (ms) để cho phép vòng lặp đươc nghỉ
trong một khoảng thời gian xác định (Đơn vị ms). Đây chính là yếu tố nhằm cải thiện việc sử dụng tài
nguyên CPU của máy tính. Bạn cũng có thể thấy điều này trong hầu hết các ví dụ về LabVIEW được
tải về trên mạng mà có sử dụng vòng lặp.
- Nhân đây cũng nên tìm hiểu qua một vài hàm timing trong LabVIEW. Có hai hàm chờ cơ bản
(wait) trong LabVIEW là Wait (ms) và Wait Until Next ms Mutiple.
Hàm Wait (ms) khi đặt trong vòng lặp có tác dụng yêu cầu vòng lặp phải chờ trong một khoảng thời
gian xác định trước khi thực thi vòng lặp tiếp theo. Lưu ý đơn vị của giá trị tại đầu vào input hàm wait
này là mili giây.
- Hàm Wait Until Next ms Multiple có tác dụng tương tự như hàm waite (ms) trong việc yêu
cầu vòng lặp phải chờ sau khi kết thúc một vòng lặp. Nhưng có một sự khác biệt trong việc thực thi
giữa hai hàm chờ này. CPU được nghỉ sau một khoảng thời gian bằng bội số của giá trị đầu vào.
*Lưu ý: là hai hàm chờ này không chỉ được sử dụng trong các vòng lặp mà ở bất cứ đâu, bạn cũng có
thể sử dụng để yêu cầu một đoạn code, một subVI hay một VI phải chờ trước khi thực thi các tác vụ.
Ngoài ra, có một số hàm về thời gian như sau:
Hình 49. Các hàm thời gian sử dụng trong vòng lặp
- Tick Count Function có tác dụng trả về giá trị thời gian của đồng hộ hệ thống của bạn.
- Bên cạnh các hàm thời gian cơ bản ở trên, LabVIEW còn cung cấp hai Express VI về thời
gian là Time Delay và Elapsed Time.
- Time Delay làm việc như hàm Wait (ms) ngoại trừ rằng thời gian mà nó nhận và trả về là ở
đơn vị giây (second).
- Elapsed Time cho phép bạn kiểm tra liệu một lượng thời gian nào đó đã trôi qua hay chưa.
Khi bạn sử dụng hàm ExpressVI này bạn phải thiết lập khoảng thời gian cần kiểm tra là bao lâu ở
ổ Elapsed timevà kết quả là tại terminal out put của Time has Elapsed (Boolean) sẽ trả về TRUE nếu
lượng thời gian bạn nhập vào đã trôi qua, nếu không thì sẽ giá trị này sẽ FALSE.
4.4.2. Kỹ thuật sử dụng vòng lặp For trong LabVIEW.
Hình 50.1. Timing trong vòng lặp For

- Tiếp theo phần kỹ thuật timing cho vòng lặp trong LabVIEW, ở phần này chúng ta sẽ cùng
tìm hiểu một vài kỹ thuật lập trình liên quan đến vòng lặp For. Trước hết bạn hãy cùng quan sát
hai Block diagram dưới đây.

- Ở Block diagram bên trái, thật dễ dàng để phát hiện ra vì sao mũi tên Run lại bị broken. Đó là
do vòng lặp For chưa được xác định số vòng lặp (Đầu vào count terminal N chưa được nối với một giá
trị quy định số vòng lặp sẽ thực thi). Song ở Block diagram bên phải, mặc dù ở đầu vào Count teminal
N vẫn chưa có giá trị nào được nối nhưng lúc này mũi tên Run lại không bị broken nữa. Vì sao?
- Đó là do tại bờ biên của vòng lặp For ta đã đưa vào một mảng Array và tại tunnel ta đã thiết
lập chế độ truyền data từ mảng vào vòng lặp là Auto-indexing (Enable indexing). Điều đó có nghĩa
rằng cỡ/size (Số phần tử) của mảng input sẽ quy định số lần lặp mà vòng lặp For sẽ thực hiện.
- Để thay đổi chế độ pass (truyền data) từ mảng vào vòng lặp, click chuột phải tại đầu
vào (tunnel input) của vòng lặp và chọn chế độ auto hay disable indexing như hình dưới đây.

- Sự khác nhau giữa auto và disable indexing là việc quy định cách thức truyền data
qua tunnel của vòng lặp: Tất cả các phần tử của mảng (auto-indexing) hay tuần tự chỉ có từng phần tử
(bắt đầu từ phần tử thứ nhất) của mảng được truyền qua (Disable indexing). Và trong Block
diagram có sự khác nhau về hình dạng của một tunnel tại hai chế độ auto hay disable indexing. Bạn có
thể thấy sự khác biệt này trong hai Block diagram trên. Bên phải là chế độ auto indexing, bên trái là
chế độ disable indexing.
- Một câu hỏi được đặt ra là nếu như cùng lúc nối vào count termial của vòng lặp For một giá
trị A và một mảng có B phần tử được nối vào vòng lặp For ở chế độ Auto index thì vòng lặp For đó sẽ
thực thi bao nhiêu lần. A lần hay B lần như Block diagram phía bên trên trong hình dưới đây (Theo đó
A nhận giá trị 7 và B nhận giá trị 11). Một trường hợp khác nữa như Block diagram phía bên dưới thì
số vòng lặp là bao nhiêu? (5, 7 hay 11)
Hình 504. Timing trong vòng lặp For

-Trong tất cả các trường hợp đó thì vòng lặp sẽ thực thi theo giá trị nhỏ nhất. Đối với Block
diagram trên thì số vòng lặp thực thi là 7 và Block diagram dưới thì số vòng lặp là 5.
Tại đầu vào của vòng lặp For có sự khác biệt như vậy nhưng ở đầu ra (out put) của vòng lặp For liệu
có sự khác biệt giữa hai chế độ pass data qua tunnel hay không? Bạn có thể tự trả lời câu hỏi đó dựa
vào kết quả hiển thị trên Front Panel với Block diagram tương ứng bên cạnh như hình dưới đây. Một
kết quả là cho ra một mảng và một kết quả chỉ là số hạng phản ánh phần tử cuối cùng của mảng đó.
- Chúng ta thường xuyên sử dụng vòng lặp For trong lập trình LabVIEW với hai thành phần
quen thuộc là Count terminal N (Quy định số vòng lặp) và interaction count i (luôn bắt đầu từ giá trị
0). Thế nhưng thử nhìn Block diagram dưới đây với cấu trúc vòng lặp For có thêm một chỉ số P (Block
diagram bên trái) và có thêm cả chỉ số C (Block diagram bên phải), bạn có quá lạ lẫm với các chỉ số
này và ý nghĩa của chúng?

- Câu trả lời rất đơn giản đó là các tham số cho phép chúng ta thiết lập chế độ thực thi vòng lặp
theo cơ chế song song trong những máy tính có bộ vi xử lí đa lõi (multi core). Theo đó, bằng việc thiết
lập của chúng ta, máy tính sẽ phân chia các lõi đảm nhiệm một phần trách nhiệm của vòng lặp. Ví dụ
như trong trường hợp lí tưởng, vòng lặp For có 10 lần lặp chạy trên máy tính dual core (hai core) thì
chương trình sẽ phân chia mỗi core thực hiện 5 vòng lặp một cách song song. Thời gian thực thi sẽ
giảm xuống một nửa so với việc ta không thiết lập cơ chế thực thi vòng lặp song song.
- Làm thế nào để thiết lập và cấu hình cơ chế thực thi vòng lặp này một cách song song? Chúng
ta chỉ đơn giản là click chuột phải lên vòng lặp và chọn thuộc tính “Configue interation parallelism” từ
menu pop up của nó. Chi tiết cấu hình như hình ảnh dưới đây.

-Tất nhiên, không phải vòng lặp nào cũng có thể thiết lập để nó thực thi với chế độ song song
được. Tuỳ thuộc vào cấu trúc code bên trong của vòng lặp For, mối liên hệ của vòng lặp đó với các
yếu tố khác trong Block diagram mà vòng lặp đó có thể chạy ở chế độ song song hay không? Việc này
thực ra đòi hỏi người lập trình phải có một sự hiểu biết nhất định về phần cứng, kỹ thuật nâng cao
trong lập trình. Song vì LabVIEW vốn là một ngôn ngữ giành cho những kỹ sư và nhà khoa học có thể
không chuyên về lập trình nên LabVIEW hỗ trợ một công cụ cho phép chúng ta kiểm tra xem liệu một
đoạn code trong một vòng lặp nào đó có thể chạy ở chế độ song song hay không. Công cụ đó nằm
trong Tool»Profile»Find Parallelizable loop…

- Sau khi gọi tính năng này từ Block diagram, cửa sổ kết quả Find Parallelizable loop Result sẽ
cho ta biết vòng lặp nào thì có thể chạy được song song.
4.4.3. Shift Registers và the Feedback Node trong các vòng lặp ( Loops).
Hình 51. Shift Registers và the Feedback Node trong các vòng lặp
- Bài viết trình bày kỹ thuật sử dụng Shift Register và Feedback Node trong các vòng lặp
(For hoặc While loop). Đây là kỹ thuật dùng để truyền dữ liệu từ một lần thực thi trước sang lần thực
thi vòng lặp tiếp theo.
Shift Registers
- Biểu tượng Shift Registers xuất hiện thành từng cặp mũi tên trên bờ biên đứng của các vòng
lặp như hình dưới đây. Đầu terminal bên phải (mũi tên hướng lên) của vòng lặp (là đầu out put) chứa
đựng giá trị của một lần thực thi vòng lặp. LabVIEW truyền dữ liệu lưu trữ ở terminal bên phải
sang terminal bên trái (Mũi tên hướng xuống). Vòng lặp sau đó sử dụng dữ liệu của terminal bên trái
như là giá trị ban đầu cho lần thực thi tiếp theo của vòng lặp. Quá trình này cứ tiếp diễn cho đến khi
vòng lặp được thực thi hết. Sau khi thực thi xong cả vòng lặp, terminal bên phải trả về và lưu trữ giá trị
cuối cùng của vòng lặp. Để đặt một Shift Register lên một vòng lặp, ta click phải lên bờ biên của vòng
lặp và chọn Add Shift Register từ menu pop up của nó. Một Shift Register có thể lưu trữ và truyền bất
cứ loại dữ liệu nào và các terminal (Trái và phải) của một Shift Register phải nối cùng một loại dữ liệu.
Chúng ta có thể đặt nhiều Shift Register lên một vòng lặp. Mỗi Shift Register sẽ làm việc độc lập với
một hoạt động nào đó trong vòng lặp.
Hình 52. Shift Registers

- Chúng ta hãy cùng phân tích hoạt động của Block Diagram trên đây với hai Shift
Register được đặt trên biên của vòng lặp. Với Shift Register phía trên, ngay sau lần lặp đầu tiên
thì terminal bên phải sẽ nhận và lưu trữ giá trị bằng 2 (là tổng của 0 và 2), sau đó giá trị 2 này sẽ được
truyền sang terminal bên trái để trở thành giá trị ban đầu của lần lặp thứ hai. Đối với Shift
Register phía dưới thì sau khi kết thúc vòng lặp đầu tiên, giá trị mà terminal bên phải nhận được là 2
(Tích của 1x2), giá trị 2 này cũng được truyền qua terminal bên trái của Shift Register phía dưới. Kết
thúc lần lặp thứ 2, giá trị nhận được của terminal bên phải ở Shift Register phía trên là 4 (tổng của 2
cọng 2) và cũng truyền sang terminal bên trái để trở thành giá trị ban đầu cho vòng lặp thứ 3. Đối
với Shift Register bên dưới thì kết thúc vòng lặp thứ hai thì giá trị nhận được ở terminal bên phải là 8
(tích của 2x4), giá trị này được truyền sang terminal bên trái và trở thành giá trị ban đầu cho lần lặp
thứ 3. Quá trình cứ thế tiếp tục như thế và bạn có thể đoán được sau khi kết thúc 10 lần lặp, thì giá trị
ở terminal bên phải của Shift Register trên và dưới sẽ bằng bao nhiêu?
Initializing Shift Registers
- Vì terminal bên trái của một Shift Register chỉ nhận giá trị từ terminal bên phải sau khi kết
thúc lần lặp thứ nhất. Vậy tại lần lặp đầu tiên thì giá trị của terminal bên trái sẽ nhận giá trị bao nhiêu
và lấy từ đâu? Chính vì lí do đó, chúng ta cần thiết lập giá trị ban đầu cho terminal bên trái ngay tại lần
lặp thứ nhất khi VI chạy ( Để làm việc này chúng ta chỉ cần nối dây từ một giá trị xác định (hằng số
hoặc control) tới đầu terminal bên trái như hình dưới đây.
Hình 53. Initializing Shift Registers

- Vòng lặp For trong Block Diagram này sẽ thực thi tổng cộng 5 lần lặp, giá trị của
các terminal tăng lên một đơn vị sau mỗi lần lặp. Kết thúc 5 lần lặp thì terminal bên phải nhận giá trị 5
và terminal bên trái nhận giá trị 4. Lưu ý rằng, cứ mỗi lần bạn chạy vòng lặp này thì giá trị
của terminal bên trái sẽ bắt đầu là giá trị 0 (Cần phân biệt mỗi lần chạy vòng lặp khác với mỗi lần lặp).
Nếu như chúng ta không nối giá trị ban đầu nào vào terminal bên trái thì vòng lặp sẽ sử dụng giá trị
mặc địch của loại dữ liệu được nối vào Shift Register ở lần chạy đầu tiên, còn các lần chạy sau đó thì
nó sẽ lấy giá trị sau cùng của lần chạy trước đó (Giá trị out put ở terminal bên phải).
- Hãy kiểm tra điều này bằng việc tạo ra một vòng lặp For mà không có giá trị ban đầu
như Block Diagram dưới đây. Ở lần chạy đầu tiên, Shift Register bắt đầu với giá trị 0 (Là giá trị mặc
định của kiểu dữ liệu 32-bit integer). Sau khi kết 5 lần lặp cho lần chạy đầu tiên của vòng lặp For này.
Đầu ra output (terminal bên phải) sẽ nhận và lưu trữ giá trị là 5. Nếu bạn lại chạy vòng lặp một lần
nữa, giá trị ban đầu của Shift Register lúc này không phải là 0 như lần chạy đầu tiên mà bắt đầu từ 5
(là giá trị cuối cùng của lần thực hiện vòng lặp trước đó). Nếu sau khi chạy lần 2 và tiếp tục chạy lần 3
thì giá trị ban đầu sẽ bắt đầu là 10 và cứ thế tăng lên nếu ta thực hiện chạy nhiều lần. Đây có thể là kết
quả mà chúng ta không mong muốn và gọi là một “Uninitializes Shift Register “.
Hình 54. Uninitialized Shift Registers
- Một “Uninitialized Shift Registers” sẽ giữ nguyên giá trị của những lần chạy trước cho tới khi
bạn đóng VI đó lại.
Stacked Shift Registers
-Một vấn đề đặt ra là nếu bạn muốn sử dụng dữ liệu của những lần lặp trước đó nhưng không
phải là ngay trước đó thì làm thế nào. Ví dụ tại lần lặp thứ n nhưng bạn có nhu cầu sử dụng dữ liệu, kết
quả của terminal bên phải (out put) tại lần lặp thứ n-2, n-3 hay trước đó 4 năm lần thì sao? Lúc này bạn
cần sử dụng “Stacked Shift Registers”. Để thiết lập một “Stacked Shift Register”, bạn click chuột phải
lên đầu terminal bên trái của một Shift Register và chọn Add Element từ Shortcut menu pop-up. Để dễ
hình dung hoạt động của các Stacked Shift Register, có thể so sánh rằng terminal bên trái là đời con
của terminal bên phải, Stacked của terminal bên trái là đời cháu của Terminal bên phải, và cứ thế nếu
bạn tạo ra một stacked của stacked nữa bằng việc click chuột phải và chọn add Element. Lưu ý
là Stacked Shift Register chỉ được đặt ở cạnh trái của vòng lặp như hình dưới đây mà thôi.
Hình 55. Stacked Shift Registers

Feedback Node
- Giống như Shift Register, một Feedback Node được sử dụng trong vòng lặp cũng lưu trữ dữ
liệu sau khi kết thúc một lần lặp, gửi dữ liệu đó tới lần lặp tiếp theo. Quá trình lặp sẽ tiếp diễn cho tới
khi vòng lặp hoàn toàn kết thúc. Tuy nhiên không có khái niệm tương đương với Stacked Shift
Register trong Feedback Node, nó chỉ lưu trữ và truyền dữ liệu ở hai vòng lặp kế tiếp nhau mà thôi.
Chúng ta cũng có thể thiết lập giá trị ban đầu cho một Feedback Node với ý nghĩa
như initialize của Shift Register.
Initializing the Feedback Node on Loop Execution
- Để thiết lập giá trị ban đầu cho Feedback Node, chúng ta nối một giá trị xác định vào
đầu terminalInitialize của Feedback Node. Hãy kiểm tra việc thực hiện Feedback Node của Block
Diagram dưới đây.
Hình 56.1. Feedback Node trong For Loop
First Execution Second Execution
Iteration End Value Iteration End Value
0 3 0 3
1 4 1 4
2 5 2 5
3 6 3 6
- Để thiết lập giá trị ban đầu cho Feedback Node, chúng ta cũng có thể Righ Click
vào initialize và chọn Move Initializer One Loop Out để một biểu tượng dấu chấm có màu tương ứng
với kiểu dữ liệu bạn nối với Feedback Node hiện ra ở bờ biên trái của vòng lặp. Đó chính
là terminal cho phép bạn nối giá trị ban đầu của Feedback Node để thiết lập giá trị ban đầu cho nó.
Trong trường hợp vòng lặp có chứa Feedback Node của bạn lại nằm trong một vòng lặp khác thì bạn
có thể click chuột phải vào initialize để di chuyển terminal initialize này ra bờ biên trái của vòng lặp
ngoài (Thực hiện bằng việc click chuột phải vào initialize terminal và chọn Move Initializer One Loop
In). Hãy tự mình kiểm tra sự thực hiện của hai thay đổi này như thế nào bằng việc tạo ra hai Block
Diagram có các vị trí initialez terminal nằm ở vòng lặp ngoài và ngay trên vòng lặp chứa trực
tiếp Feedback Node.
Hình 56. Feedback Node trong While Loop
- Nếu chúng ta không nối giá trị nào vào initialize terminal của Feedback Node, vòng lặp sẽ
hoạt động tương tự như trường hợp Uninitialized Shift Registers. Hãy tạo ra một Block Diagram có
chứa vòng lặp như hình dưới đây để kiểm tra việc thực thi của nó. Trường hợp này gọi là “unwired
initializer terminal” của Feedback Node.
Hình 56.2. Feedback Node trong For Loop
First Execution Second Execution
Iteration End Value Iteration End Value
0 1 0 5
1 2 1 6
2 3 2 7
3 4 3 8
- Mặc dù bạn có thể tách Feedback Node và initialize terminal của nó rời ra nhau (như trường
hợp đặt trên biên của vòng lặp For hay While ở trên, song bạn không thể tách riêng ra khỏi vòng lặp
hay cấu trúc của Feedback Node (Bờ biên của các vòng lặp chứa Feedback Node là giới hạn cuối cùng
của sự tách riêng). Bạn cũng không thể tách chúng riêng rẽ ra khi bạn tạo một SubVI chứa Feedback
Node và initialize terminal của nó nằm ngoài SubVI đó. Nếu bạn làm thế thì trong cả hai trường hợp
trên, LabVIEW đều báo lỗi.
Thay thế Shift Registers bằng một Feedback Node
- Bạn hoàn toàn có thể thay thế một Shift Register bằng một Feedback Node bởi việc click
chuột phải lên Shift Register và chọn Replace with Feedback Node từ Shortcut menu. Hay bạn cũng có
thể làm ngược lại là thay thế một Feedback Node bằng Shift Register với việc lựa chọn Replace with
Shift Register.
V. Mảng
5.1.Khái niệm về mảng và cách tạo mảng
- Ngoài các loại dữ liệu như đã bàn ở các bài trước, LabVIEW cũng hỗ trợ các cấu trúc dữ kiểu
liệu mảng. Như trong ngôn ngữ dựa trên văn bản, Mảng là một khối có nhiều chiều (n-chiều) của một
loại dữ liệu nào đó các phần tử trong mảng được đánh chỉ số. Và ta có thể truy suất các phần tử này
thông qua các chỉ số đó. Không giống như trong các ngôn ngữ dựa trên văn bản, mảng LabVIEW được
tự động thay đổi kích cỡ để phù hợp với dữ liệu của nó.
Hình 57. Mảng 1 chiều dạng so, 2 chiều dạng boolean, và 3 chiều dạng chuỗi
- Cách tạo một mảng như sau: Vào FP> Modern >Array, Matrix> Lấy array ra đặt tại FP.
Hình 58. Lấy mảng từ FP

- Tạo array dạng số bằng cách lấy Numeric control đưa vào array.
Hình 59. Tạo Numeric array
- Rê chuột trên mảng cho tới khi có biểu tượng sau: , kéo dài mảng để có một mảng 1
chiều có 5 phần tử.
Hình 60. Kéo dài mảng

- Copy ra một mảng nữa bằng cách nhấn giữ Ctrl+C và nhấn giữa chuột trái lên mảng trên và
kéo xuống.
Hình 61. Copy nhanh một mảng

- Dùng phép cộng nối 2 mảng này lại. Tạo Indicator phía bên phải của hàm cộng, ta được một
chương trình tính tổng 2 mảng.
Hình 62. Chương trình hoàn thiện
- Nhập giá trị vào hai mảng Control. Nhấn chạy chương trình. Ta thấy tổng của hai mảng chính
là tổng của các thành phần tương ứng trong mảng.
5.2. Trích dữ liệu từ một mảng

- Ta tiếp tục trích một phần tử từ mảng kết quả để nắm thêm về khái niệm phần tử và chỉ số
trong mảng. Để thực hiện VI này ta hãy:
Hình 63. Kết quả phép cộng 2 mảng

- Vào BD> Programming> Array> Index Array
Hình 64. Lấy hàm Index array

- Nối Index array vào array kết quả từ chương trình trên. Nhập giá trị 0 vào ô Index và tạo
Indicator tại chân element của hàm Index array. Ta được một chương trình cho phép truy xuất các giá
trị của mảng. Ví dụ: Muốn truy xuất giá trị của phần tử có chỉ số 0 thì ta nhập 0 vào ô Gia trị index. Cụ
thể ở đây ta có kết quả là 2. Nếu Giá trị index là 1 thì ta có kết quả là 3, vv..
Hình 65. Chương trình truy xuất giá trị thành phần trong array.
- Khi sử dụng array trong For loop. Bạn cần lưu ý một số vấn đề. Cùng nhau xem một ví dụ
trên ni.com trong hình 1.46 để giải thích rõ hơn vấn đề này. Chương trình này là một for loop, for loop
này lặp lại 15 lần phép cộng các thành phần trong 2 array (array 1 có 10 phần tử, array 2 có 20 phần
tử). Kết quả trả về chỉ là một array có 10 phần tử. Lý do: Khi for loop thực hiện tới vòng lặp thứ 11 thì
array 1 sẽ không có phần tử thứ 11 nên phép cộng không thể tiếp tục thực hiện.
Hình 66. Tổng 2 array

- Các Array lớn hơn 1 chiều bạn có thể dễ dàng tạo ra bằng cách ghép các For loop lại với
nhau theo hướng [5]. Chú ý rằng bạn cần chọn chế độ Auto-indexing trên thành các For loop trong các
trường hợp này.
Hình 67. Tạo array 2 chiều
VI. Bó
- Bó là kiểu dữ liệu hoạt động như hộp đen có khả năng lưu trữ các loại dữ liệu khác nhau. Có
thể hiểu rằng: Bó được coi là một nhóm các giá trị dữ liệu được đóng gói với nhau để tạo thành một
kiểu dữ liệu phức tạp hơn, và thường có ý nghĩa hơn.
- Ví dụ: Hãy tạo một Output cluster (là một Indicator) chứa các thông tin sau: Họ tên, tuổi, giới
tính. Thực hiện như sau:
FP> Mordern> Array, Matrix, > Cluster
Kéo thả cluster ra ngoài FP
Hình 68. Kéo thả Cluster ra Front panel

- Đưa vào Cluster này 1 Ctring control để nhập họ tên
- Đưa vào thêm 1 Numeric control để nhập tuổi
- Một LED để chỉ định giới tính (Nam thì LED sáng, Nữ thì LED tắt)
- Nhập các dòng: Họ tên: Nguyễn Bá A, Tuổi: 28, Boolean: Sáng.
- Ta được Cluster control như hình 1.50.
Hình 69. Cluster đã tạo ra
-Bây giờ, ta hãy tạo một Cluster indicator như hình 1.51.
Hình 70. Tạo Cluster indicator

- Cho chương trình chạy, ta được kết quả như hình 71
Hình 71. Kết quả tạo ra là Cluster indicator sẽ hiển thị đúng Cluster control
- Như vậy ta vừa biết phương pháp tạo một cluster. Bây giờ ta sẽ tạo một Cluster như trên bằng
cách sử dụng hàm Bundle (tổng hợp) như sau.
- Lấy các String control, Numeric control và LED đặt tại FP.
- Lấy hàm Bundle tại BD> Programming> Cluster> Bundle. Kết nối lần lượt các control vào
Bundle này và tạo Cluster indicator như bài trên.
Hình 72. Phương pháp tạo Cluster bằng hàm Bundle

- LabVIEW cũng cung cấp hàm Unbundle để ta bóc tách các phần tử trong một bó.
- Lấy một Unbundle nối vào Output cluster. Tạo các indicator từ hàm Unbundle này. Ta sẽ có
kết quả là Họ tên, Tuổi và giới tính riêng lẽ. Đ ây chính là việc bóc tách các phần tử trong một bó.
Ta có thể dùng hàm Unbundle by name để bóc tách họ tên.
Hình 73. Bóc tách các phần tử trong một bó
VII. Việc tạo ra các VI con

- Trong phần này, chúng ta sẽ tìm hiểu về một sub VI, cách tạo cũng như sử dụng trong
LabVIEW.
7.1. Thế nào là một SubVI?

- Một SubVI là một VI được sử dụng trong một VI khác.
- Giả sử ta có một chương trình tính giá trị của hàm y = . Thực hiện chương trình với 3 giá
trị của x tại x1, x2 và x3 như hình 74.
Hình 74
- Chương trình được thực hiện đơn giản bằng cách thực hiện phép tính nhân các giá trị đầu vào
với chính nó và hiển thị kết quả.
- Phải thay đổi gì khi thay đổi hàm đã cho thành y = + 1?
- Tránh việc 1 đoạn code bị lặp lại nhiều lần không cần thiết, hãy thay thế việc tính hàm y =
bằng 1 VI và thay vào chương trình hiện như hình 2. Khi đó, hàm Labview VI y= trở thành một
SubVI.
Hình 75
- Một VI có thể phục vụ như một giao diện người dùng hoặc một hoạt động bạn sử dụng
thường xuyên. Sau khi bạn học làm thế nào để xây dựng một giao diện và một sơ đồ khối, bạn có thể
tạo ra các VI và các VI con và các tuỳ biến VI mà thuộc quyền sở hữu của bạn.
- Sau khi bạn xây dựng một VI, bạn có thể sử dụng nó trong một VI khác. Một VI được gọi từ
sơ đồ khối của VI khác được gọi là VI con. Bạn có thể sử dụng lại một VI con trong các VI khác. Để
tạo ra một VI con, bạn cần xây dựng một bảng nối và tạo ra một biểu tượng. Mỗi VI đều có một icon,
nó nằm ở góc trên bên phải của cả 2 cửa sổ Front panel và Block diagram.
- Để hiểu rõ cách tạo subVI và icon, connector panel của nó thì ta làm ví dụ sau. Tạo giao diện
Front panel của VI và trong Block Diagram ta liên kết giống hình 76.1 và 76.2 bên dưới:
a) Giao diện b) Sơ đồ khối
Hình 76. Ví dụ minh họa
7.2. Làm thế nào khai báo tham số cho một subVI?
- Trước khi bạn xây dựng một VI mới, bạn nên xem xét việc tìm kiếm một ví dụ VI mà đáp
ứng các yêu cầu của bạn bằng việc lựa chọn Help>>Find Examples để mở ví dụ tìm ra NI Example
Finder. Nếu bạn không tìm thấy một ví dụ VI thích hợp, mở một VI mẫu từ hộp thoại New và cư trú
bảng mẫu với các VI và các hàm chức năng gắn sẵn tư bảng mẫu Functions.
- Các bước tạo một SubVI:
· Tạo một VI với tham số đầu vào và đầu ra (các control hoặc indicator).
· Viết code cho VI
· Kiểm tra
· Trên front panel, di chuyển chuột vào biểu tượng của LabVIEW nằm ở góc phải của
VI và click chuột phải và chọn Show Connector trên menu vừa xuất hiện.
Hình 77
· Click chuột vào vị trí trên biểu tượng và chọn kết nối với các control và indicator
tương ứng trên front panel. Tùy vào số lượng các tham số, bạn có thể click phải chuột và chọn kiểu và
số lượng connector sao cho phù hợp với số lượng tham số cần thiết cho subVI.
Hình 78
· Để tạo icon thì ta click phải vào biểu tượng ở góc phải bên trên của Front panel hoặc Block
diagram. Sau đó bảng Icon Editor xuất hiện như hình dưới, trong đó có các công cụ dùng để vẽ tương
tự trong Paint.
Hình 79. Cửa sổ Icon Editor Giả sử ta vẽ biểu tượng như sau:
Hình 80. Ví dụ minh họa vẽ Icon
- Sau đó save lại với tên PTB1.vi và tạo một VI mới. Có thể click phải vào block digram của
VI sau đó vào Function pallete Select a VI… Rồi trỏ tới tập tin PTB1.vi hoặc ta có thể kéo biểu tượng
của PTB1.vi đang mở sang block diagram của VI mới.
7.3.sử dụng một subVI như thế nào?

- Trong block diagram, click chuột phải và chọn Select a VI…, chọn VI cần dùng và click OK.
- Nối các tham số tương ứng với subVI.
Hình 81
7.4. Việc tạo các VI con từ các thành phần của một VI.
- Chuyển một thành phần của một VI vào trong một VI con bằng cách sử dụng công cụ
Positioning để lựa chọn thành phần của sơ đồ khối bạn muốn sử dụng lại và lựa chọn Edit>>Create
SubVI . Một biểu tượng cho VI con mới thay thế phần được lựa chọn của sơ đồ khối. LabVIEW tạo ra
các điều khiển và các dụng cụ chỉ thị cho VI con mới, tự động định dạng ô vuông đầu nối dựa trên số
lượng của các thiết bị điều khiển và dụng cụ chỉ thị bạn đã lựa chọn, và nối dây VI con tới những dây
hiện hữu.
- Việc tạo một VI con từ một thành phần là tiện lợi nhưng còn đòi hỏi việc quy hoạch cẩn thận
để tạo ra một trật tự logic của các VI. Xem xét những đối tượng nào chứa trong thành phần và tránh sự
thay đổi chức năng của VI tổng.
7.5. Việc thiết kế các giao diện VI con.

- Đặt các dụng cụ chỉ thị và các điều khiển trên giao diện chúng xuất hiện trong ô vuông đầu
nối.
- Đặt các điều khiển vào bên trái của giao diện và dụng cụ chỉ thị ở bên phải.
- Đặt các cụm error in vào góc trái dưới của giao diện và các cụm error out vào góc phải.
7.6. Lưu các VI.

- Chọn File>>Save để lưu một VI. Khi bạn lưu một VI, bạn cần phải sử dụng một cái tên để mô
tả để bạn có thể nhận ra một cách dễ dàng sau đó. Bạn cũng có thể lưu các VI cho một phiên bản trước
đây của LabVIEW làm cho LabVIEW trở nên tiện lợi và để trợ giúp bạn gìn giữ các VI trong 2 phiên
bản của LabVIEW khi cần thiết.
7.7. Việc đặt tên các VI.

- Khi bạn lưu các VI, sử dụng những cái tên mô tả. Những tên miêu tả, chẳng hạn như
Temperature Monitor.vi và Serial Write & Read.vi, để nhận ra một VI dễ dàng và biết được bạn sử
dụng nó như thế nào. Nếu bạn sử dụng những cái tên không rõ ràng, chẳng hạn như VI#1.vi bạn phải
tìm nó, khó khăn để nhận ra các VI, đặc biệt nếu bạn đã lưu vài VI với nhau.
- Xem xét xem liệu những người dùng sẽ chạy các VI của bạn trên nền khác. Tránh việc sử
dụng các ký tự mà một số hệ điều hành dành riêng cho những mục đích đặc biệt như \ : / ? * < > và #.
*Lưu ý:
- Nếu bạn có vài VI có tên giống nhau đã lưu vào trong máy tính của bạn, tổ chức cẩn thận các
VI trong những thư mục khác nhau hoặc các LLB (LabVIEW file that contains a collection of related
VIs for a specific use - file LabVIEW mà chứa đựng một tập hợp các VI liên quan cho một sử dụng
đặc biệt) để tránh sự tham chiếu LabVIEW lệch hướng VI con khi đang chạy VI lớp trên.
7.8.Việc lưu giữ một phiên bản trước.

- Bạn có thể lưu các VI cho một phiên bản trước của LabVIEW để tiện lợi cho việc nâng cấp
LabVIEW và để hỗ trợ bạn gìn giữ các VI trong 2 phiên bản của LabVIEW khi cần thiết. Chọn
File>>Save For Previous Version để lưu phiên bản trước của LabVIEW.
- Khi bạn lưu một VI vào một phiên bản trước, LabVIEW không chuyển đúng VI đó như mọi
VI trong trật tự của nó, loại trừ các file trong thư mục labview\vi.lib.
- Thường thì một VI sử dụng chức năng không sẵn có trong phiên bản trước của LabVIEW.
Trong những trường hợp như vậy, LabVIEW lưu lại như nhiều VI như nó có thể và đưa ra một thông
báo là không thể chuyển đổi nó được. Thông báo xuất hiện ngay lập tức trong hộp thoại Warning. Kích
nút OK để ghi nhận các cảnh báo đó và đóng hộp thoại. Kích nút Save to File để lưu các cảnh báo tới
một file văn bản để quan sát lại sau đó.
7.9. Tuỳ biến các VI.

- Bạn có thể định dạng các VI và các VI con để làm phù hợp với ứng dụng của bạn cần. Ví dụ,
nếu bạn dự định sử dụng một VI như một VI con, yêu cầu người sử dụng đầu vào, định dạng VI vì vậy
mà giao diện của nó xuất hiện mỗi lần bạn gọi nó.
- Chọn File>>VI Properties để định dạng sự xuất hiện và hoạt động của một VI. Sử dụng menu
kéo xuống Category tại đỉnh của hộp thoại VI Properties để lựa chọn từ vài phạm trù tuỳ chọn khác
nhau.
- Hộp thoại VI Properties bao gồm các phạm trù tuỳ chọn sau đây:
• General: sử dụng trang này để xác định đường dẫn hiện thời mà một VI đã lưu, số duyệt lại
của nó, lịch sử duyệt lại, và bất kỳ sự thay đổi nào làm ra từ khi VI đã được lưu trước đó.
Documention: sử dụng trang này để thêm một sự mô tả của VI và liên kết tới một chủ đề file trợ giúp.
• Security: sử dụng trang này để khoá hoặc đặt mật khẩu một VI.
• Window Appearance: sử dụng tang này để tuỳ biến sự xuất hiện cửa sổ của các VI, chẳng hạn
như cửa sổ tiêu đề và kiểu.
• Window Size: sử dụng trang này để thiết đặt kích thước của cửa sổ.
• Execution: sử dụng trang này để định dạng một VI chạy như thế nào. Ví dụ, bạn có thể định
dạng một VI để chạy ngay lập tức khi nó được mở hoặc tạm dừng khi nó được gọi như một VI con.
• Editor Options: sử dụng trang này để đặt kích thước của lưới sắp thành hàng cho VI hiện thời
và để thay đổi kiểu của điều khiển và dụng cụ chỉ thị LabVIEW tạo ra khi bạn kích phải một thiết bị
đầu cuối và chọn Create>>Control hoặc Create>>Indicator từ menu tắt.
VIII.THỰC HÀNH
Phần 1: Các vòng lặp và chart.
A. Lý Thuyết
1. Vòng lặp While
- Thực thi lệnh cho đến khi gặp điều kiện dừng. Trong Block Diagram, chọn Functions >
Structures, dùng trỏ chuột click và chọn đường biên vòng lặp sao cho bao quanh đoạn code cần thực
hiện.
-Vòng lặp While thực thi chương trình bên trong vòng lặp cho đến khi conditional terminal
nhận 1 giá trị Boolean nhất định nào đó. Khi điều kiện dừng là Continue If True, vòng lặp While sẽ
thực thi chương trình cho đến khi conditional terminal nhận giá trị False. Iteration Terminal biểu thị số
lần lặp lại đã thực hiện xong. Khi thực hiện vòng lặp lần thứ nhất, Iteration Terminal trả lại giá trị là 0.
- Block diagram sau cho ta thấy, vòng lặp While thực thi chương trình cho đến khi giá trị ngõ
ra từ SubVI nhỏ hơn 10 hay điều khiển Enable có giá trị là False.
- Ngược lại, ta có thể thay đổi hoạt động của conditional terminal bằng cách click phải chuột
hay đường biên của vòng lặp While và chọn Stop If True. Vòng lặp sẽ ngừng cho đến khi conditional
terminal nhận giá trị TRUE như hình sau.
2. Waveform Chart
- Chọn Controls > Graph palette . Waveform chart cho phép hiển thị cùng lúc 1 hay nhiều plot,
một hay nhiều tín hiệu như sau:
- Chart có 3 kiểu khác nhau để hiển thị data. Click phải chuột, chọn Advanced > Update Mode,
chọn Strip Chart, Scope Chart hay Sweep Chart. Kiểu mặc định là Strip Chart.
• Strip Chart: hiển thị dữ liệu đang running liên tục từ trái sang phải
• Scope Chart: hiển thị một phần của dữ liệu từ trái sang phải
• Sweep Chart: tương tự như Scope chỉ hiện thị một phần của dữ liệu nhưng lại hiển thị
data cũ bên phải và data mới bên trái ngăn cách với nhau bởi 1 vạch thẳng đứng như hình sau:
- Trong Block Diagram, ta có thể nối trực tiếp ngõ ra scalar đến 1 waveform chart như sau:
- Để hiển thị nhiều plot cùng lúc, chọn Functions > Cluster . Có thể thêm nhiều plot bằng cách
thay đổi lại kích thước của Bundle như hình sau:
3. Thanh ghi dịch (shift registers).

- Với các vòng lặp While và For, ta có thể sử dụng Shift register để truyền giá trị từ 1 vòng lặp
này đến vòng lặp khác. Để tạo shift register, click phải chuột tại đường biên của vòng lặp và chọn Add
shift register. Shift register chứa 2 terminal ngược nhau trên đường biên của vòng lặp như hình sau:
- Terminal bên phải chứa giá trị dữ liệu sau khi hoàn tất 1 vòng lặp, sau đó dữ liệu này được
dịch khi kết thúc vòng lặp và nó xuất hiện tại terminal bên trái bắt đầu 1 vòng lặp mới như hình sau:
- Một shift register có thể lưu trữ bất kỳ loại dữ liệu nào: numeric, boolean, string, array…. Ta
có thể cấu hình shift register lưu trữ các giá trị từ các vòng lặp trước, thuận lợi khi chúng ta cần tính trị
trung bình của các điểm giá trị. Để tạo thêm các terminal cho phép truy xuất các giá trị từ các vòng lặp
trước đó, click phải chuột vào terminal bên trái và chọn Add Element.
- Để khởi tạo thanh ghi dịch với 1 giá trị cho trước bên ngoài vòng lặp, ta nối giá trị khởi tạo
này với terminal bên trái của shift register. Giá trị khởi tạo chính là giá trị mặc định cho loại dữ liệu
của shift register. Nếu loại dữ liệu của shift register là Boolean thì giá trị khởi tạo có giá trị là False.
Nếu shift register có loại dữ liệu là numeric thì giá trị khởi tạo là 0.
4. Vòng lặp For.
- Khác với vòng lặp While thực thi chương trình cho đến khi gặp gặp điều kiện dừng, vòng lặp
For thực thi chương trình với số lần lặp lại cho trước. Vòng lặp For gồm 2 terminal: count terminal
định số lần thực thi chương trình và iteration terminal biểu hiện số lần lặp đã thực hiện xong.
B. Thực hành
Bài 1.
a. Thực hiện chương trình sử dụng vòng lặp While tạo tín hiệu ngẫu nhiên và hiển thị trên Scope Chart
như sau:
có Block diagram như sau:
Hướng dẫn:
• Chọn Waveform Chart, click phải chuột, chọn Visible Item > Plot Legend cho phép ẩn legend
• Chọn trục x-axis, click phải chuột, chọn Visible Scale Label để xóa label của trục x.
• Chọn Functions > Time & Dialog, định thời gian thực hiện 1 vòng lặp.
• Functions > Numeric, chọn hàm Random number.
b. Thực hiện chương trình tạo 1 số ngẫu nhiên đến khi bằng với 1 giá trị cho trước có Front Panel và
Block Diagram như sau:
Hướng dẫn:
• Number to match control chỉ rõ giá trị cần đạt đến
• Current Number indicator hiển thị giá trị ngẫu nhiên hiện thời # iteration hiển thị số lần lặp lại
trước khi bằng với giá trị cần.
• Thiết lập data range cho Number to match control: 0 – 10000.
• Thiết lập độ chính xác cho các controls và indicators.
• Chạy chương trình với number to match control: 50, 100, 11000. Nhận xét?
Bài 2: Thực hiện chương trình ứng dụng Shift register như sau:
Bài 3. Thực hiện chương trình sử dụng vòng lặp For như sau:
a. Tạo 100 số ngẫu nhiên và xuất ra waveform chart.
b. Thực hiện VI biểu diễn 2 plot ngẫu nhiên trên Sweep chart: plot biểu diễn tín hiệu ngẫu nhiên và 1
plot còn lại biểu diễn trị trung bình của 4 giá trị trước đó.
Hướng dẫn:
• Sử dụng vòng lặp For (N = 200)
• Sử dụng 3 terminal bên trái để lấy trị trung bình của 4 giá trị dữ liệu trước đó.
• Chọn Functions > Cluster để nhóm giá trị ngẫu nhiên và trị trung bình trước khi vẽ chúng trên
cùng 1 chart.
Bài 4. Chỉ sử dụng vòng lặp While, kết hợp vòng lặp While và For sao cho chương trình dừng lại khi
nó đạt đến giá trị cho trước trên control panel hoặc khi bật nút Stop.
Phần 2: Mảng, giản đồ và cấu trúc Cluster

A. Lý thuyết
1. Array.
- Mảng là tập hợp các phần tử dữ liệu cùng loại (numeric, string, Boolean, cluster). Một mảng
có thể là 1 hay nhiều chiều, mỗi chiều có đến 231 phần tử.
Các bước tạo array control hay indicator:
Chọn Controls > Array & Cluster
Drag chọn đối tượng dữ liệu vào bên trong phần tử array.
Mảng 2 chiều cần 2 chỉ số hàng và cột.
*Tạo array constant:

- Chọn Functions > Array. Drag các đối tượng dữ liệu với các loại khác nhau vào array shell:
2. Graph:
- Giản đồ cho phép biểu thị dữ liệu 2D hay nhiều hơn nữa. Có 2 loại là XY graph và waveform
graph.
3. Cluster
- Cluster là loại cấu trúc dữ liệu kết hợp một hay nhiều thành phần dữ liệu thành 1 loại dữ liệu
mới. Cluster khác với array là các thành phần hình thành nên cluster có thể là các loại dữ liệu khác
nhau như Boolean, String, Numeric.
- Tạo Cluster control hay indicator: Controls > Array & Cluster. Tất cả các đối tượng dữ liệu
trong cùng 1 cluster phải hoàn toàn là controls hoặc hoàn toàn là indicator.
- Để tạo 1 cluster constant, chọn Functions > Cluster > Cluster Constant.
- Cần lưu ý thứ tự của các đối tượng dữ liệu trong 1 cluster. Muốn thay đổi thứ tự, click phải
chuột, chọn Reorder Controls in Cluster.
B. Thực hành
Bài 1. Thực hiện array sử dụng các vòng lặp
a. Thực hiện array 1 chiều sử dụng vòng lặp For/While sử dụng khả năng auto-indexing
b. Click phải chuột trên đường biên của vòng lặp, chọn Disable Indexing. Cho biết kết quả?
c. Tạo array 2 chiều:
Bài 2. Thực hiện một số chức năng của array

a. Chức năng Array size:
b. Chức năng Initialize array:
c. Chức năng Build array:
d. Chức năng Array subset
e. Chức năng Array index
Bài 3. Thực hiện VI sau:
Bài 4. Viết VI đảo ngược 1 mảng n phần tử tạo trước, vd: a[0] ↔ a[n-1], a[1] ↔ a[n-2], …
Bài 5. Thực hiện các giản đồ sau
a. Giản đồ trình bày 1 plot duy nhất:
b. Giản đồ trình bày nhiều plot:
c. XY graph:

a.
b.
Phần 3. Cấu trúc case và chuỗi

A. Lý thuyết.
1. Cấu trúc Case
- Chọn Functions > Structures, Case. Tùy thuộc vào selector terminal: nếu là numeric hay
string sẽ có 231 – 1 trường hợp cho cấu trúc Case, nếu là Boolean thì có 2 trường hợp True và False.
2. Chuỗi:
- Thực hiện chương trình theo trình tự
3. Formula Node:
- Thực hiện các biểu thức đa biến và phức tạp một cách đơn giản hơn

- Chọn Functions > Structures > Formula Node. Click phải chuột trên đường biên, chọn Add
Input/ Add Output để tạo các biến đầu vào và biến ngõ ra. Các biểu thức trong Node cách nhau bởi dấu
chấm phẩy.
B. Thực hành
Bài 1. Thực hiện các VI sau
a.
b.
Hướng dẫn:
• Thực hiện chương trình trong vòng lặp While trước.
• Chọn Functions > Structures > Sequence Structure bao quanh đoạn code vừa thực hiện.
• Click phải chuột vào đường biên, chọn Add Frame After.
• Chọn frame chứa vòng lặp While, click phải chuột, chọn Make This Frame >>0.
• Chọn Functions > Time & Dialog > Tick count: đọc giá trị hiện thời của đồng hồ hệ thống.
Bài 3. Thực hiện các Formula Node như sau
a.
b. Vẽ graph biểu thị phương trình sau: y = f(x)^3 + f(x) với f(x) = tanh(x) + cos(x).
Bài 4.
a. Chỉ sử dụng 1 Formula Node để giải 2 phương trình sau:
b. Thực hiện Front Panel gồm 2 ngõ vào và 1 indicator biểu diễn kết quả các phép toán: cộng, trừ,
nhân chia từ 2 giá trị ngõ vào.
c. Thực hiện chương trình gồm 2 ngõ vào: 1 là giá trị ngưỡng và 1 input aray. Một ngõ ra biểu diễn giá
trị ngõ vào bé hơn giá trị ngưỡng cho trước.
Phần 4. String và file I/O
A. Lý thuyết
1. String
- String là chuỗi các ký tự ASCII có thể hoặc không thể hiển thị. String là kiểu dữ liệu không
phụ thuộc platform.
- String được dùng để: Tạo thông báo dạng text, chuyển dữ liệu dạng số thành chuỗi để truyền
và chuyển ngược lại khi xử lý, lưu thông tin vào file, tạo hướng dẫn hoặc nhắc nhở trong hộp thoại.
- Trên Front Panel, String có thể xuất hiện ở Text Entry Box, Table hoặc Label
Các kiểu hiển thị String: Normarl display, Code display, Password display và Hex display.
- Tạo String, Controls > String & Path
2. File I/O:
- Cho phép lưu trữ hay thu nhận thông tin từ file hoặc đĩa khác. Chọn Functions > File I/O.
Labview hỗ trợ rất nhiều hàm cho các thao tác file I/O. Chia làm 3 loại sau:
• Loại High-Level File Vis
• Loại Imtermediate File Functions
• Loại Advanced File Functions:
B. Thực hành
Bài 1: Thực hiện các chức năng của String:
a. String length:
b. Concatenate Strings:
c. String Subset:
d. Math Pattern:
e. Chuyển từ string sang số
f. Chuyển từ số sang string
Bài 2. Thực hiện VI sau
Bài 3. Thực hiện VI sau

a. Write function
b. Read functions:
Hướng dẫn:
• Chọn Analyze > Signal Processing > Signal Generation cho Sine pattern, Uniform White
Noise.
• Chọn Functions > Array cho Transpose 2D Array
** Bài tập nhỏ:
1. Điều chỉnh núm, cho biết kết quả trên Bình chứa nước và Chỉ báo số
của mực nước ở bên cạnh Bể.
2. Đèn giao thông có 3 màu, Đèn đỏ tồn tại trong 10 giây, Đèn xanh kéo dài
trong 10 giây và ánh sáng vàng kéo dài trong 5 giây. Hãy để nó chạy không ngừng cho đến khi nhấn
nút Dừng.
3. Nhập một số, kiểm tra xem đó có phải là số nguyên tố không. Nếu đó là sự thật, hãy bật Ánh sáng
và hiển thị rất tuyệt! Nếu không, đừng bật Đèn và hiển thị Không!".
4. Nhập một số n, chạy trong cấu trúc vòng lặp để tính tổng của
các số từ 0 đến n-1. Cho biết kết quả trong thanh dọc.
5. Điền vào một mảng với 3 bối cảnh: Tên, Năm sinh, Công việc. Chiều dài của mảng là đầu vào của
người dùng. Khi bạn điều chỉnh số Chỉ mục, ví dụ: tại chỉ mục 3, dữ liệu là {Haul, 1988, Driver}, hiển
thị dữ liệu trên Mảng. Nếu nhấn Show, tất cả thông tin được hiển thị trên cụm.
6. Nhập một chuỗi, xoay chuỗi đó.
7. Thực hiện chuyển đổi, nếu nó BẬT. Hiển thị thông tin bao gồm 3 loại dữ liệu:
Nhân đôi, số nguyên, chuỗi. Nếu nó TẮT, hiển thị thông tin của 3 giá trị với
cùng loại dữ liệu.
8. Nhập số n, vẽ giá trị ngẫu nhiên từ 0 đến n trên biểu đồ, Dừng vòng lặp sau 10 giây.
9. Đếm số lượng chữ cái từ một chuỗi bạn nhập.
IX. Lập trình nâng cao trong Labview

10.1. Biến đổi Fourier rời rạc
10.1.1. Khái niệm chung
- Khi lấy mẫu tín hiệu, các mẫu của tín hiệu tạo thành sự biểu diễn miền thời gian của tín hiệu.
sự biểu diễn này đưa ra các biên độ của tín hiệu ở các khoảng thời gian nó được lấy mẫu. Tuy nhiên,
trong nhiều trường hợp ta lại quan tâm đến tần số của tín hiệu hơn là biên độ của các mẫu. Sự biểu
diễn tín hiệu theo tần số được gọi là sự biểu diễn theo miền tần số của tín hiệu.Sự biểu diễn miền tần
số có thể cho biết bản chất bên trong của tín hiệu và hệ thống tạo ra tín hiệu.
- Để chuyển các mẫu dữ liệu từ miền thời gian sang miền tần số có thể dùng thuật toán biến đổi
Fourier rời rạc - Discrete Transform (DFT). Thuật toán DFT thiết lập mối liên quan giữ các mẫu của
một tín hiệu trong ,iền thời gian và sự biểu diễn của chúng trong miền tần số. Thuật toán DFT được
ứng dụng rộng rãi trong phân tích phổ, cơ học ứng dụng, viễn thông,….
*Biến đổi FOURIER nhanh.
- Thuật toán DFT xử lý N mẫu với độ phức tạp thuật toán xấp xỉ . Nếu N là một số lũy thừa
của 2 (N= ) thì độ phức tạp thuật toán xấp xỉ NlnN. Như vậy thuật toán DFT có thể tính nhanh hơn
và gọi là biến đổi nhanh Fourier – Fast Fourier Transform (FFT).
- Ưu điểm của thuật toán FFT là tốc độ và bộ nhớ vì nó có thể tính FFT trực tiếp tức là không
phải có thêm bộ nhớ đệm. Tuy nhiên, nó chỉ áp dụng được khi độ dài lũy thừa của 2. Thuật toán DFT
có thể áp dụng với dãy có độ dài bất kỳ nhưng nó lại chậm hơn và dùng nhiều bộ nhớ hơn vì phải cấp
phát bộ đệm phụ để lưu các kết quả trung gian trong quá trình thực hiện.
- Một kỹ thuật thường được dùng để làm đầu vào có số phần tử là lũy thừa của 2 là thêm các
điểm 0 vào cuối của dãy đầu vào. Việc thêm vào này không làm ảnh hưởng đến phổ của tín hiệu.
- Thư viện phân tích của Labview có 2 VI tính FFT của tín hiệu là Real FFT VI và Complex
FFT VI. Trong đó, Real FFT VI tính FFT của tín hiệu thực còn Complex FFT VI tính giá trị cảu tín
hiệu phức.
10.1.2. Các VI xử lý tín hiệu.
*Các VI miền tần số.
- Hình 2-1 minh họa các VI miền tần số. Để lấy các VI miền tần số có thể truy nhập vào
Functions>>Singnal Processing>>Frequency Domain. Các VI miền tần số gồm có:
• Buneman Frequency Estimator, Power Spectrum, Cross Power, Complex FFT, Real
FFT, Inverse Real FFT, STFT Spectrogram, Fast Hilbert Transform, Inverse Fast Hilbert Transform
Unevenly Sampled Signal Spectrum, FHT, Inverse FHT, Walsh Hadamard, Walsh Hadamard Inverse,
WVD Spectrogram, Laplace Transform Real, Wavelet Transform Daubechies4, Wavelet Transform
Daubechies4 Inverse.
• Để tham khảo thêm về các VI này có thể xem trong Help Onlinecuar chúng.
Hình 82. VI xử lý tín hiệu.

*Các VI miền thời gian.
- Để truy cập vào các VI này ta vào Functions>>Signal Processing>>Time Domain. Các VI
miền thời gian gầm có:
•AutoCorrelation, Convolution, CrossCrrelation, Decimate, Deconvolution, Derivative
x(t), Integral x(t), Unwrap Phase, Y[i] = Clip, {X[i]}, Y[i] = X[i-n], Zero Padder.
10.2. Các bộ lọc số - Digital Filter
*Giới thiệu về các bộ lọc số.
- Các bộ lọc tương tự là một phần quan trọng trong khi thiết kế mạch. Các công cụ lấy mẫu và xử
lý tín hiệu số hiện đại khiến nó có thể được thay thế bằng các bộ lọc số trong các ứng dụng đòi hỏi sự
linh hoạt và lập trình được. Cá bộ lọc số tiên tiến hơn những bộ lọc tương tự ở các điểm sau :
 Chúng là các phần mềm có thể lập trình.
 Chúng ổn định và có thể dự đoán được.
 Chúng không bị trôi bởi nhiệt độ, độ ẩm và không yêu cầu phải có các thành phần chính
xác.
a) Các bộ lọc IIR và FIR.
Sự phân biệt giữa IIR và FIR là dựa trên đáp ứng xung của nó. Các bộ lọc IIR là các bộ lọc có đáp
ứng xung vô hạn còn các bộ lọc FIR có đáp ứng xung hữu hạn. Đáp ứng xung là hữu hạn hay vô hạn là
dựa vào cách tính toán ở đầu ra. Các bộ lọc FIR có đầu ra chỉ phụ thuộc vào giá trị đầu vào hiện tại còn
IIR thì không những phụ thuộc vào đầu vaopf hiện tại mà còn phụ thuộc vào các đầu ra trước đó. Vì
vậy bộ lọc IIR còn gọi là các bộ lọc đệ quy còn FIR là các bộ lọc không đệ quy.
Nhược điểm của các bộ lọc IIR là đáp ứng pha của chúng là phi tuyến. Nếu ứng dụng không yêu
cầu thông tin về pha thì có thể dùng IIR.
*Bộ lọc IIR
Bộ lọc IIR là các bộ lọc đáp ứng xung về lý thuyết là vô hạn. Phương trình vi phân cảu
chúng có dạng như sau :
(∑ ∑ ) (*)
Bộ lọc IIR trong Labview có đắc điểm sau :

 Các chỉ số âm mà là kết quả của phương trình (*) được gải sử bằng 0 ở lần đầu gọi VI.
 Vì trạng thái khởi tạo được gải thiết bằng 0 (với các chỉ số âm) nên quá trình quá độ diễn
ra trước khi bộ lọc ổn định sẽ tỉ lệ với bậc (order) của bộ lọc. Sự tồn tại của đáp ứng quá độ
hay thời gian giữ chậm (delay) đối với các bộ lọc thông cao và thopong thấp bằng với bậc
bộ lọc (delay=order).
 Thời gian tồn tại của quá trình quá độ đối với bộ lọc dải thông và dải chặn bằng hai lần bậc
của bộ lọc (delay=2*order).
 Có thể loại bỏ đáp ứng quá độ ở lần gọi kế tiếp bằng cách đặt bộ nhớ trạng thái hoạt động.
Để thực hiện đặt init/cont control của VI bằng TRUE.
Ưu điểm của bộ lọc này là bộ lọc yêu cầu ít hệ số hơn để thực hiện. Do đó bộ lọc hoạt động
nhanh hơn và khoongyeeu cầu vùng nhớ mở rộng.
Nhược điểm của bộ lọc là đáp ứng pha của nó là phi tuyến.
Labview có các bộ lọc IIR sau:
 Các bộ lọc Butterworth: Đáp ứng tần số của bộ lọc là đáp trơn ở tất cả các tần số và giảm
đơn điệu từ tần số cắt. Bộ lọc Butterworth là trơn tối đa – đáp ứng lý tưởng bằng 1 ở dải
thông và bằng 0 ở dải chặn. Ưu điểm cảu nó là có đáp ứng tần số trơn và giảm đơn điệu.
Sau khi đặt tần số cắt, Labview sẽ đặt độ dốc của quá trình quá độ với bậc của bộ lọc. Bộ
lọc bậc càng cao thì càng tiến tới bộ lọc thông thấp lý tưởng.
 Các bộ lọc Chebyshev: Các bộ lọc Chebyshev giảm tối thiểu đỉnh lỗi ở dải thông. Đặc
tuyến của đáp ứng tần số có đáp ứng biên độ lớn ở dải thông, giảm đơn điệu biên độ ở giải
chặn và có vùng chuyển tiếp sắc hơn bộ lọc Butterworth. Điều này khiến sai số tuyệt đối
nhỏ hơn và tốc độ thực hiện nhanh hơn.
 Bộ lọc Chebyshev II (hay còn gọi là bộ lọc Chebyshev đảo: bộ lọc này tương tự như bộ lọc
Chebyshev nhưng có phân số sai số trên dải chặn và có sự bằng phẳng nhất ở dỉ thông.
 Bộ lọc Eliptic (Cauer): các bộ lọc loại này giảm tối đa các sai số đỉnh bằng cách phân bố
chúng trên khắp dải thông và dải chặn. So với các bộ lọc Butterworth và Chebyshev cùng
bậc thì bộ lọc Eliptic có quá trình quá độ giữa giải thông và giải chặn là sắc nhất. Vì vậy, nó
được dùng rộng rãi.
 Bộ lọc Bessel: có thể dùng để giảm sự méo pha phi tuyến vốn có trong các bộ lọc IIR. Ở
các bộ lọc bậc cao hơn và với vùng gấp dốc hơn thì méo pha càng rõ nét đặc biệt ở vùng
quá độ cảu bộ lọc. Bộ lọc này có đặc tuyến trơn tối đa ở cả pha và biên độ. Đặc tuyến pha ở
dải thông cảu bộ lọc thì gần như tuyến tính. Cũng giống như bộ lọc Butterworth, bộ lọc
Bessel đòi hỏi bộ lọc bậc cao để giảm sai số, vì vậy nó ít đc dùng.
*Bộ lọc FIR
Các bộ lọc đáp ứng hữu hạn FIR là các bộ lọc số mà có đáp ứng xung là hữu hạn. Các bộ
FIR cũng gọi là các bộ lọc không đệ quy. Phương trình sai phân cảu bộ lọc là:
Trong đó x biểu diễn dãy đầu vào

y biểu diễn dãy đầu ra
h biểu diễn hệ số bộ lọc
Các bộ lọc FIR có các đặc điểm quan trọng sau :
 Chúng có thể đạt được pha tuyến tính bởi sự đối xứng của hệ số.
 Chúng luôn ổn định.
 Có thể thực hiện các hàm lọc dùng tương quan chéo và nới chung luôn gắn một khoảng trễ
với dãy đầu ra.
Delay = với n là hệ số của bộ lọc FIR
Có thể truy cập vào các bộ lọc trong Labview bằng cách chọn Functions>>Signal
Processing>>Filters. Hình 2 minh họa các bộ lọc trong Labview.
Hình 83. Các bộ lọc trong Labview

Tai - Lieu - LabVIEW - FULL

Uploaded by

Copyright:

Available Formats

You might also like

Tai - Lieu - LabVIEW - FULL

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tai - Lieu - LabVIEW - FULL

Uploaded by

Copyright:

Available Formats

Tài liệu được sưu tầm và chia sẻ miễn phí tại ARDUINO IOT VIETNAM

1.1. LabVIEW là gì? ..................................................................................................... 5

1.2. Vai trò của LabVIEW ............................................................................................ 5

1.3. Các chức năng chính của LabVIEW ...................................................................... 5

1.4. Phần mềm nhúng vào LabVIEW ........................................................................... 6

1.5. Các giao thức kết nối .............................................................................................. 6

1.6. Các Module và bộ công cụ LabVIEW ................................................................... 7

1.6.1. Các module LabVIEW .................................................................................... 7

1.6.2. Các bộ công cụ LabVIEW .............................................................................. 7

1.7.Thế mạnh của Labview. .......................................................................................... 7

1.8. LabVIEW làm việc như thế nào? ........................................................................... 8

1.9. Các thành phần của LabVIEW? ............................................................................. 8

1.10.Dòng dữ liệu trong LabVIEW. ............................................................................ 12

1.11. Thuật toán. .......................................................................................................... 13

II. Các công cụ hỗ trợ lập trình ....................................................................................... 15

2.1. Tools Palette ......................................................................................................... 15

2.2. Bảng điều khiển (Controls Palette) ...................................................................... 16

2.2.3. Graph: Bao gồm Graph 2D, Graph 3D ......................................................... 19

2.3. Bảng các hàm chức năng (Function palette) ........................................................ 20

2.3.1. Hàm cấu trúc - Structures Function: ............................................................. 21

2.3.2. Hàm mảng – Function Array: ....................................................................... 27

2.3.5. Hàm Boolean - Boolean Function:................................................................ 36

2.3.6.Hàm chuỗi – String Function: ........................................................................ 39

2.3.7. Hàm so sánh – Comparison Functions:......................................................... 42

2.3.8. Hàm Thời gian – Time function:................................................................... 46

2.3.9.Hàm Dialog & User Interface: ....................................................................... 48

2.3.10. Hàm File I/O - File I/O Function: ............................................................... 48

2.3.11. Hàm dạng sóng - Waveform: ...................................................................... 49

2.3.12. Hàm điều khiển ứng dụng- Application Control: ....................................... 50

2.3.13. Hàm đồng bộ hoá - Synchronization Function: .......................................... 51

2.3.14.Hàm đồ họa và âm thanh - Graphic & Sound Function:.............................. 51

2.3.15. Hàm phát sinh báo cáo - Report Generation Function:............................... 52

2.4. Các loại Control và Indicatior .............................................................................. 53

2.4.1. Các Control thường dùng .............................................................................. 53

2.4.2. Các dạng Indicator thường dùng. .................................................................. 54

III. Kiểu dữ liệu trong LabVIEW và chuyển đổi dữ liệu. ............................................... 57

4.1. Vòng lặp While (While Loop). ............................................................................ 61

4.2.Vòng lặp For (For Loop) ....................................................................................... 63

4.4. Kỹ thuật sử dụng vòng lặp trong labview. ........................................................... 66

4.4.1. Kỹ thuật Timing cho vòng lặp trong LabVIEW. .......................................... 66

4.4.2. Kỹ thuật sử dụng vòng lặp For trong LabVIEW. ......................................... 69

5.1.Khái niệm về mảng và cách tạo mảng .................................................................. 80

5.2. Trích dữ liệu từ một mảng.................................................................................... 82

VII. Việc tạo ra các VI con ............................................................................................. 87

7.1. Thế nào là một SubVI?......................................................................................... 87

7.3.sử dụng một subVI như thế nào? .......................................................................... 92

7.5. Việc thiết kế các giao diện VI con. ...................................................................... 93

7.6. Lưu các VI. ........................................................................................................... 93

7.7. Việc đặt tên các VI. .............................................................................................. 93

7.8.Việc lưu giữ một phiên bản trước. ........................................................................ 93

7.9. Tuỳ biến các VI. ................................................................................................... 94

VIII.THỰC HÀNH ......................................................................................................... 95

Phần 1: Các vòng lặp và chart. .................................................................................... 95

Phần 2: Mảng, giản đồ và cấu trúc Cluster ............................................................... 104

Phần 3. Cấu trúc case và chuỗi.................................................................................. 109

IX. Lập trình nâng cao trong Labview .......................................................................... 120

1.1. LabVIEW là gì?

1.2. Vai trò của LabVIEW