[LabVIEW] Tự học labview

[setwon]

Bài 5: Cấu trúc CASE, SEQUENCE, EVENT và FORMULA NODE (Đỗ Trung Hiếu - CYBERLAB JSC.)

Trong bài này ta sẽ tìm hiểu một số cấu trúc còn lại hay được sử dụng trong LabVIEW.
1. Cấu trúc CASE:

Cấu trúc CASE trong LabVIEW có tác dụng giống như cấu trúc rẽ nhanh CASE trong lập trình C/C++. Đó là dạng cấu trúc rẽ nhánh cho phép chương trình có nhiều lựa chọn khác nhau tùy thuộc vào đầu vào.
Để tạo cấu trúc CASE, ta click chuột phải chọn Programming >> Structures >> Case structure
Ta tạo một cấu trúc case trên block diagram như sau:

Khi mới khởi tạo, điều kiện đầu vào có kiểu dữ liệu Logic (Boolean).
Điều kiện đầu vào cũng có thể là chuỗi ký tự, số, enum…

Khi muốn chuyển sang Case khác, ví dụ hiện tại là True case, ta ấn vào mũi tên tam giác chỉ xuống cạnh chữ True, chọn False, nội dung bên trong case structure sẽ chuyển sang hiển thị False case.

Ví dụ:
Viết chương trình cảnh báo trạng thái của biến đầu vào, nếu biến lớn hơn giá trị đặt, đèn Led nhấp nháy, nếu không đèn Led không sang.

Chương trình như sau:

Đây là chương trình khi điều kiện đầu vào lớn hơn giá trị đặt (10) thỏa mãn, ta thực hiện một phép đảo giá trị Led (nhấp nháy Led Alarm) sau mỗi vòng lặp.

Còn đây là chương trình khi điều kiện đầu vào là False:

Ta cũng có thể thiết lập đầu vào của Case là dạng khác Boolean, ví dụ:
• Dạng string: bạn chú ý khi đặt đầu vào là String, ta phải chú ý nhập đúng chính xác tên của điều kiện trong dấu ngoặc kép, nếu không LabVIEW sẽ coi như đó là một trường hợp khác.
• Dạng enum: enum là một kiểu số Integer nhưng được đại diện bởi một tên nhất định. Sử dụng kiểu Enum ta sẽ ít gặp phải khả năng bị nhầm tên như khi sử dụng String, hơn nữa, sử dụng Enum cũng sẽ giảm bớt đáng kể dung lượng bộ nhớ được sử dụng.
Ví dụ sau thực thi phép toán:
• Cho đầu vào là 1 số nguyên X và 1 đèn Led
• Nếu X=0 thì đèn Led tắt
• Nếu X=1 Led nháy với chu kỳ 100ms
• Nếu X=2 Led nháy với chu kỳ 200ms
• Các trường hợp khác Led sáng
Bài toán này là một ví dụ về việc đầu vào của Case là số. Chương trình với từng trường hợp của đầu vào được lập trình như sau:



Chú ý:
• Để tạo thêm 1 case mới, ta click phải vào cạnh của Case structure, chọn "Add case after" hoặc "Add case before".
• Default Case là trường hợp trong đó X bằng giá trị điều kiện, hoặc bằng bất cứ giá trị nào chưa được nêu trong điều kiện đó. Ví dụ trong bài toán này, Default case phải là 3 hoặc 4 hoặc bất cứ số nào khác 0,1,2.
• Thường mặc định ban đầu X=0 sẽ là "Default case", muốn "default case" là 3, ta tạo Case X=3, và click chuột phải vào Case structure, chọn "Make this the default case"
Enum:
Enum bản chất tập hợp các số thông thường, nhưng mỗi số được đại diện bằng 1 tên riêng.
Để tạo Enum trong Front panel, ta chọn: Modern >> Ring & Enum >> Enum
Biểu tượng trong Block Diagram và Front Panel của 1 Enum như sau

Để tạo thêm phần tử trong Enum, ta click phải vào biểu tượng, chọn Properties >> Edit Items

Ta thêm các phần tử với các tên tương ứng như sau hình trên.
Như vậy ta đã tạo ra các phần tử với các tên: "So 0" tương ứng với 0; "So 1" tương ứng với 1; "So 2" tương ứng với 2; Ta có thể thêm phần tử cuối là "So con lai" tương ứng với 3.
Sau đó ta sẽ thay thế Enum vừa tạo cho số X trong ví dụ Case Structure trên, ta thấy Case structure tự nhận tập hợp các số Enum vừa tạo như là tên của từng trường hợp.

Sau này, ta sẽ thấy Enum được sử dụng rất thông dụng trong các bài toán sử dụng Case, đặc biệt là các bài toán sử dụng Máy trạng thái mà tôi sẽ nói đến trong những phần sau của mục này.
...(còn tiếp)

[setwon]

...(tiếp bài 4)
4. Bài giải
Trong bài trước, tôi có để lại 2 bài tập nho nhỏ, chắc các bạn đều đã giải quyết được. Đối với những bạn chưa biết cách giải, tôi xin tóm tắt đáp án như sau:
Bài 1: Vẽ đồ thị đường tròn từ 1000 điểm trên đường tròn đó, bán kính 1 đơn vị.
Phân tích:
Chúng ta đều biết tọa độ các điểm trên đường tròn có thể biểu diễn bằng hàm lượng giác sau:
X = sin (phi); Y = cos (phi) với phi = [0,2pi].
Như vậy để vẽ 1000 điểm trên đường tròn, ta dung vòng lặp For trong 1000 vòng lặp, và phi = i*2pi/1000 (vì có 1000 điểm, nên mỗi vòng lặp phi tăng 2pi/1000 (rad)
Từ đó ta có mảng các tọa độ các điểm (X[i],Y[i])
Chương trình như sau:

Kết quả:

Với bài còn lại cách làm tương tự, không khó lắm nên tôi nghĩ không cần giải nữa.
Các bạn cũng có thể thay đổi chương trình để giải các bài toán vẽ đồ thị phức tạp hơn. Tôi rất mong các bạn đóng góp các ý tưởng và ví du. Một số đồ thị sau cũng khá thú vị các bạn có thể thử.
5. Vòng lăp For và mảng đa chiều:
Trong Bài 2: Array và Cluster, tôi đã giới thiệu qua về mảng 2 chiều (2D Array), đó là một mảng của các mảng 1 chiều.
Sau đây tôi xin nói rõ hơn về loại mảng này và các ứng dụng của nó, cũng như thao tác với mảng đa chiều sử dụng For loop.
Mảng đa chiều là một tập hơp các phần tử cùng loại, được sắp xếp theo tọa độ hàng và cột. Có nhiều cách để tạo mảng đa chiều:
• Cách 1: Tạo mảng hằng số
• Cách 2: Tạo mảng dạng biến điều khiển
• Cách 3: Tạo bằng vòng lặp For
Với 2 cách trên rất đơn giản nhưng diễn giải thì dài dòng, các bạn tự tìm hiểu.
Tôi chỉ xin giới thiệu cách thứ 3:
Ví dụ: Tạo mảng 2 chiều với 4 cột, 5 hàng, với số phần tử tăng dần từ phần tử đầu tiên cho đến cuối cùng, tăng từ trái sang phải, trên xuống dưới. Kết quả ra sẽ phải như sau:

Ta sẽ sử dụng 2 vòng lặp For lồng trong nhau, vòng lặp trong để tạo từng hàng 4 phần tử, và vòng lặp ngoài để tạo mảng 2 chiều từ 5 mảng 1 chiều vừa tạo (vòng For có 5 lần lặp). Để ý chú thích.

Cũng giống như với mảng 1D, bạn cũng có thể sử dụng For loop để tách mảng 2 chiều ra từng phần tử (phần tử mảng hoặc phần tử số). Bạn phải làm theo trình tự, đầu tiên tách từng mảng 1 chiều ra từ mảng 2 chiều, sau đó tách từng phần tử trong mảng một chiều:

Trong chương trình như hình, tôi giới thiệu 2 cách để cộng từng phần tử trong mảng 2 chiều trong LabVIEW: cách dùng vòng lặp For tách từng phần tử và thực hiện phép cộng, và cách đơn giản là dùng phép cộng vào mảng

Ví dụ trên down mang 2 chieu va For loop.vi
Sau đây tôi tạm kết thúc bài giới thiệu về vòng lặp For. Còn nhiều ví dụ và bài tập thú vị liên quan đến vòng lặp này, nhưng cần thêm kiến thức bổ sung, vì thế ta sẽ trở lại với vòng lặp này sau. Hẹn gặp lại các bạn ở bài tiếp theo: Bài 5: Cấu trúc Case, Sequence và Event.

[setwon]

Bài 4: Vòng lặp FOR và các thủ thuật với Array (Đỗ Trung Hiếu - CYBERLAB JSC.)

Trong mục này, chúng ta sẽ tìm hiểu một cấu trúc vòng lặp khác cũng rất thông dụng: vòng lặp FOR.
1. Vòng lặp FOR:

Trong khi vòng lặp While là cấu trúc lặp có điều kiện, vòng lặp For là vòng lặp không điều kiện. Vòng lặp For thực hiện một số lượng vòng lặp xác định trước khi dừng.
Để tạo vòng lặp For, ta chọn Programming >> Strutures >> For loop. Và tạo giống như vòng lặp While.
Chú ý trong vòng lặp For, đầu vào N là số vòng lặp được thực hiện. Còn lại cách thực thi vòng lặp For giống với vòng lặp While. Biến đếm i sẽ chạy từ 0 cho đến (N-1).
Vòng lặp For cũng có thể tạo điều kiện dừng và điều kiện chạy như vòng lặp While, bằng cách click phải vào 1 cạnh của vòng lặp, chọn Conditional Terminal. Với cách này ta có thể dừng vòng lặp ngay cả khi số vòng lặp chưa đạt đến giá trị đặt.

Bạn cũng có thể tạo Shift Register, Feedback node và Local Variable trong vòng lặp For tương tự với cách của vòng lặp While. Chương trình dưới đây sử dụng vòng lặp For để tính toán ra giá trị thứ N của một dãy Fibonacy, quy luật của dãy là:

• F(0)=0;
• F(1)=1;
• F(n+2)=F(n+1)+F(n);

2. Vòng lặp FOR và mảng (Array):

Sau đây tôi muốn giới thiệu một thủ thuật khá thú vị khi làm việc với mảng của vòng lặp For.
Ta có thể sử dụng vòng lặp For để duyệt một mảng, trong khi không cần phải biết số phần tử trong mảng, bằng cách đơn giản nối mảng đó vào trong vòng lặp. Vòng lặp sẽ tự động tính ra số vòng lặp để duyệt hết mảng, và mỗi vòng lặp lần lượt tách ra phần tử thứ (i) trong mảng đó.
Khi nối đầu ra từ trong vòng lặp For ra ngoài, ta cũng có thể tạo một mảng với số phần tử bằng số vòng lặp của For.

Ví dụ trên tạo ra 1 mảng 20 phần tử (Loop 1), rồi phân tích mảng đó ra từng phần tử, nhân mỗi phần tử với 2, rồi tạo ra 1 mảng 20 phần tử khác từ các kết quả đó.

Bạn cũng có thể truyền nguyên vẹn giá trị của mảng hay giá trị vào trong vòng lặp hoặc từ vòng lặp ra bằng cách click chuột phải vào vị trí nối ở trên rìa vòng lặp, chọn Disable Indexing

3. Ví dụ Sử dụng vòng lặp For và mảng để tạo tín hiệu tuần hoàn:
Một số bài toán tạo tín hiệu có thể phải sử dụng các phép tính toán học phức tạp, tốn kém tài nguyên và bộ nhớ máy tính. Để giảm tải công việc tính toán cho máy tính ta thường sử dụng một Mảng ghi nhớ sẵn các giá trị của hàm đó (nếu hàm đó tuần hoàn) và công việc tính toán sẽ chỉ cần thực hiện một lần.
Ví dụ thực hiện tạo tín hiệu có giá trị tuần hoàn theo thời gian là hàm sau:
Y(t) = sin(2pi*t) + sin(2*2pi*t) + cos (3*3pi*t)
Với thời gian tăng mỗi đơn vị là 0.01 s
• Ta đã biết hàm trên là một hàm tuần hoàn có chu kỳ là T = 1s
• Vì thế chỉ cần thực hiện tính toán trong 1 chu kỳ của hàm đó, rồi lặp lại ở các chu kỳ sau
• Trước tiên sử dụng vòng lặp FOR để tạo mảng:
• Với thời gian tăng mỗi đơn vị là 0.01s, một chu kỳ sẽ bao gồm 100 phần tử.
• Để tạo mảng như vậy ta lập trình như sau:

Trong đó T là mảng lưu trữ giá trị thời gian, và Y là mảng lưu trữ giá trị tín hiệu cần tạo.
Để hiển thị toàn bộ tín hiệu vừa tạo ta sử dụng XY Graph trong Front Panel: Click phải vào Front Panel, chọn Graph Indicators >> XY Graph, Đấu dây như hình trên.
Tiếp theo, ta sử dụng vòng lặp While và vòng lặp FOR kết hợp để thực hiện biểu diễn xuất tín hiệu tuần hoàn từ mảng vừa tạo.
Kết quả:

* Chú ý: Thay vì sử dụng vòng lặp For, ta cũng có thể sử dụng hàm Index Array để tách tín hiệu tử mảng.
Down ví dụ signal gen For loop.vi
Bài tập: Sử dụng vòng lặp For và XY Graph vừa học để lập trình vẽ các đồ thị sau:
a) Đồ thị đường tròn từ 1000 điểm trên đường tròn đó, bán kính 1 đơn vị.
b) Đồ thị hàm số y = 2x^4+3x^3-5x^2+x+1., với x từ [-10 đến 10], lấy 100 giá trị.
...(còn tiếp)

[setwon]

...(tiếp bài 3)
5. Feedback Node
Trong mục trên ta đã biết sử dụng Shift Register để thực hiện các thuật toán lưu trữ giá trị của vòng lặp trước.
Tuy nhiên một nhược điểm của Shift Register là tốn không gian trong chương trình, vì cần phải nối từ đầu này tới tận đầu kia của vòng lặp, do đó trong lập trình đồ họa như LabVIEW, là một bất lợi.
Vì thế có một số cách khác để giải quyết điều này, đó là Feedback Node và Local Variable.
Để tạo một Feedback Node, tao Click chuột phải Block Diagram, chọn Programming >> Strutures >> Feedback Node
Điều khác biệt của Feedback Node so với các hàm khác trong LabVIEW, là Đầu vào feedback node ở bên phải, cập nhật giá trị cho vòng lặp sau, và đầu ra ở bên trái, là giá trị ở vòng lặp trước đó.

Ví dụ, quay trở lại bài toán nhấp nháy đèn Led đã nói ở trên, ta lập trình sử dụng Feedback Node:

Ta thấy chương trình đã gọn hơn rất nhiều so với chương trình trước đó. Điểm lợi của Feedback node so với Shift register là có thể đặt dễ dàng ở bất cứ vị trí nào trong chương trình, tuy nhiên lại không lưu trữ được giá trị ở nhiều hơn 1 vòng lặp trước đó.
6. Local Variable
Trong các ví dụ trước kia tôi mới chỉ giới thiệu các chương trình chạy với 1 vòng lặp. Một trong những điểm mạnh nhất của LabVIEW, đó là cho phép người dùng lập trình đa luồng, đa lõi và đa tác vụ một cách hết sức dễ dàng (những ai biết sâu về lập trình C, C++, C# có lẽ đều hiểu lập trình đa luồng là một lĩnh vực không thực sự đơn giản)
Với LabVIEW, bản thân ngôn ngữ ngay từ đầu đã hỗ trợ lập trình đa luồng. Trong một chương trình, bạn có thể bố trí nhiều vòng lặp để thực hiện nhiều tác vụ khác nhau, ví dụ:
• Vòng lặp Xử lý Giao diện người dùng (User Interface Loop)
• Vòng lặp xử lý các tác vụ-sự kiện (Event-Task Loop)
• Vòng lặp thu thập dữ liệu (Data Acquisition)
• Vòng lặp hiển thị/lưu trữ dữ liệu
• Vân vân…
Và đương nhiên, các vòng lặp này cũng cần được giao tiếp, trao đổi dữ liệu với nhau.
Local Variable là một công cụ hỗ trợ cho việc trao đổi dữ liệu đó.
Ví dụ tạo 2 vòng lặp khác nhau, một vòng lặp cho người dùng thay đổi giá trị Slide bar, bật tắt các Led, và dừng chương trình, vòng lặp kia hiển thị giá trị Slide Bar và trạng thái các Led. Mỗi vòng lặp chạy với chu kỳ khác nhau.
Để tạo ra Local Variable của một biến (ví dụ Slide bar), bạn click chuột phải vào biến đó, chọn Creat >> Local Variable.
Khi khởi tạo 1 Local Variable, có thể mặc định ở trạng thái đầu vào (Write), để chuyển sang trạng thái đầu ra (Read), Click chuột phải vào Local Variable đó, chọn Change to Read. Làm tương tự khi muốn chuyển sang Write.
Bạn cũng có thể thay đổi biến tham chiếu của Local Variable đó bằng các click chuột trái, chọn biến khác.
Thiết kế chương trình như sau:

Lúc này có thể bạn chưa thể chạy được chương trình (cứ thử chạy xem, sẽ báo lỗi !). Đó là vì Thiết lập Cơ khí của các nút (Mechanical Action) không tương thích để có thể sử dụng Local Variable cho nó.
Để sửa đúng, quay trở lại Front Panel chương trình, click phải lên các nút Stop và OK Button, chọn Mechanical Action >> Switch Until Released (trước kia là Latch when released).
Bây giờ chương trình đã có thể chạy. Thay đổi các giá trị của Slide, ấn nút OK, thay đổi Boolean và quan sát các hiển thị, bạn thấy 2 vòng lặp đã liên lạc được với nhau. Ấn Stop để dừng chương trình, 2 vòng lặp sẽ cùng dừng.
Các ví dụ down tại:
• Led toggle using feedback node.vi
• local variable sample.vì
(hết bài 3 )
Bài tiếp theo: Bài 4: Vòng lặp FOR và các thủ thuật với Array

[setwon]

...(tiếp bài 3)
Ví dụ tính toán đạo hàm và tích phân:
Sau đây ta sẽ tận dụng kiến thức đã biết về Shift Register để thực thi các đạo hàm và tích phân của hàm vừa tạo.
Công thức tính gần đúng đạo hàm của hàm y = f(x):
• Y'(n) = [f(n) - f(n-1)] / dt
• hoặc phương pháp chính xác hơn : y'(n-2) = [-f(n)+8*f(n-1)-8*f(n-3)+f(n-4)]
Ở đây ta sẽ sử dụng phương pháp đầu tiên. Chú ý: dt = 50ms=0.05s.

Trong ví dụ trên, ta sử dụng Shift Register để lưu trữ đầu ra f(n). Do đó có thể coi đầu ra từ shift register giá trị của đầu vào nhưng của vòng lặp trước.
Kết quả hiển thị trên Front Panel, ta được hàm gần đúng Cos (t), là đạo hàm của Sin (t).

Các bạn cũng có thể thực hiện gần đúng bằng phương pháp thứ 2, sử dụng Shift Register để lưu trữ giá trị của trước đó 2,3,4… vòng lặp, bằng di chuột xuống dưới đầu vào shift register và kéo xuống:

Trong ví dụ trên sử dụng Shift Register lưu trữ giá trị của 4 vòng lặp trước đó của đầu vào biến đếm i, kết quả ra là giá trị đã được lưu trữ của 1, 2, 3, 4 vòng lặp:

(còn tiếp)...

[setwon]

...(tiếp bài 3)
3. Shift Register
Shift Register là một cách để lưu dữ liệu lại cho các vòng lặp sau. Ví dụ khi bạn muốn thực hiện chương trình nhấp nháy Led, thuật toán là sau mỗi vòng lặp, bạn đảo trạng thái của Led ở thời điểm trước đó. Để làm được vậy, bạn cần lưu trạng thái của Led, sử dụng Shift Register.
Click chuột phải vào rìa bên trái của vòng lặp While, chọn Add Shift Register, được như hình dưới:

Ô có mũi tên bên trái lưu giá trị được cập nhật ở vòng lặp trước, ô có mũi tên bên phải lưu giá trị mới được cập nhật cho vòng lặp sau. Ban đầu Shift Register chưa chứa kiểu giá trị nào. Để đặt giá trị ban đầu cho Shift Register, đưa vào đó 1 giá trị bất kỳ, ví dụ: kiểu logic

Đặt một hàm Not để đảo giá trị của biến logic lưu trong Shift Register sau mỗi vòng lặp, và nối một Led Indicator vào đó. Ta đã thực hiện một thuật toán nhấp nháy Led.
Để có thể thấy Led nháy chậm như dự kiến, đưa vào chương trình một hàm Delay. Chạy chương trình để thấy Led nháy (xem file ví dụ)
4. Ví dụ tạo và hiển thị hàm Sin:
Trong ví dụ này ta sẽ thực hiện các hàm Sin(t), Sin (2t), Sin (3t) với t là thời gian thực. Giá trị sẽ được tín toán và xuất ra với chu kỳ 50ms
• Vì giá trị được tính toán và xuất ra với chu kỳ 50ms, ta cần vòng lặp có hàm Delay 50ms.
• Để thực hiện đúng hàm Sin (t) với t là thời gian thực tính bằng giây, ta có thể sử dụng biến đếm i. Ta sẽ có: t = (i*50)/1000 (s) = i * 0.05
• Thực hiện hàm Sin (t) = Sin (i*0.05), tương tự với các hàm khác.
• Ta có 3 đầu ra, để hiển thị cùng lúc 3 đầu ra trên 1 Chart, ta sử dụng khối Bundle trong Programming >> Cluster, Class, Variant
• Bố trí chương trình như hình dưới

Chạy chương trình, ta được kết quả:

* Chú ý: Khối Formula node là khối cho phép lập trình dạng dòng lệnh các phép toán phức tạp, dưới dạng ngôn ngữ lập trình tương tự C. Đây là một công cụ hết sức hiệu quả và mạnh mẽ trong LabVIEW, chúng ta sẽ quay trở lại với nó sau này.
Để tạo Formula node, ta click chuột phải vào Block Diagram, chọn Programming >> Structures >> Formula Node
...(còn tiếp)

[setwon]

Bài 3: Vòng lặp While , Shift Register, Feedback node và Local Variable

(Đỗ Trung Hiếu - CYBERLAB JSC.)
1. Vòng lặp While:

Trong các bài trước mà tôi đã đăng, các chương trình đều chỉ thực hiện một lần sau khi ấn nút Run, thực thi thuật toán, xuất kết quả, và dừng lại.
Để chương trình có thể thực và cập nhật giá trị liên tục, và chỉ dừng khi ta muốn, chúng ta sử dụng vòng lặp While.
Vòng lặp While thuộc dạng vòng lặp có điều kiện, chỉ dừng lại khi điều kiện đó được thỏa mãn.
Để tạo 1 vòng lặp While, ta ấn chuột phải trong Block Diagram, chọn Programming >> Structure >> While Loop
Sau đó, bạn có thể vẽ 1 hình chữ nhật với kích thước bất kỳ. Đó chính là Vòng lặp While.

Nút màu đỏ là điều kiện dừng của vòng lặp. Khi giá trị logic đưa vào Điều kiện dừng có giá trị đúng (True) thì vòng lặp dừng, nếu không, vòng lặp sẽ tiếp tục thực hiện.
Ấn vào nút Điều kiện dừng, nút đó chuyển thành biểu tượng như hình bên. Đó là điều kiện chạy. Khi đầu vào logic điều kiện chạy có giá trị đúng, vòng lặp tiếp tục chạy. Nếu không, vòng lặp sẽ dừng.
Ô có chữ (i) màu xanh lam ở góc của vòng lặp là itoration (biến đếm vòng lặp). Mỗi khi vòng lặp thực hiện xong 1 chu kỳ lặp, i sẽ tăng lên 1 đơn vị. i đến tăng từ 0.
Xem ví dụ sau đây: thực hiện 2 vòng lặp While khác nhau, cùng chạy đủ 100 lần lặp (i đếm từ 0 đến 99 thì dừng.
Kết quả cuối cùng của i đều là 99.

2. Thời gian thực thi vòng lặp và các hàm Delay:
Trong ví dụ trên, ta có thể thấy thời gian thực thi vòng lặp While là rất nhanh, đó là vì máy tính thực hiện các task trong vòng lặp với thời gian rất nhỏ (nhưng không nhỏ hơn 1ms)
Để có thể thiết lập thời gian thực thi cho các vòng lặp này một cách gần đúng, ta sử dụng các hàm Delay.
Click chuột phải trên Block Diagram, chọn Programming >> Timming >> Wait (ms) hoặc Wait Until ms Multiple

Hai hàm trên đều có tác dụng thực thi một tác vụ delay với số mili giây bằng đầu vào của hàm. Sự khác nhau là: Hàm Wait thực hiện phép Delay thời gian cho trước sau khi thực hiện các tác vụ trong hàm While, còn hàm Wait Until ms Multiple cố định thời gian thực hiện các tác vụ trong hàm While trong khoảng thời gian định trước, bất kể các tác vụ trong hàm là gì.
Thiết lập đầu vào cho hàm Delay, thêm vào một Slide bar control, và một Chart như trong hình:

Chạy chương trình, di chuyển Slide bar, ta thấy kết quả được hiển thị trên Chart, với tốc độ 100ms mỗi vòng.
Thay đổi đầu vào hàm Delay để quan sát tốc độ nhanh chậm của vòng lặp.
...(còn tiếp)

[HocLabVIEW]

hay quá anh ơi! phát huy nhé

[setwon]

... (tiếp bài 2)
2. Array các Array, các hàm với Array:
2.1 Các hàm với Array:
LabVIEW cũng hỗ trợ một thư viện tương đối phong phú các hàm với Array, các bạn có thể tìm thư viện này trong: Block Diagram >> Programming >> Array

Trong thư viện này, có chưa các hàm:
• Tìm kích thước mảng : Array Size
• Tìm phần tử trong mảng theo Index: Index Array
• Tạo Array: Build Array
• Tìm phần tử lớn nhất/ nhỏ nhất; Max & Min
• Xóa phần tử trong mảng: Delete From Array
• Chèn phần tử trong mảng: Insert Into Array
• Sắp xếp mảng 1 chiều : Sort 1D Array
• Vân vân
Trong bài viết nhỏ này tôi không thể liệt kê tất cả các hàm về mảng cũng như về bất kỳ lĩnh vực gì, vì thế để thành thạo labview và sử dụng trong thực tế, các bạn phải chịu khó tự tìm hiểu và thử nghiệm với các ví dụ tự tạo ra. Sau đây là một ví dụ mẫu:

Ví dụ này sử dụng các hàm để tính kích thước mảng, tìm phần tử (index =3) trong mảng, chèn phần tử mới vào vị trí có index =3, và tìm ra phần tử có giá trị max, min và index của các phần tử đó
Dưới đây là Front panel biểu thị kết quả

2.2 Mảng các mảng hay Mảng 2 chiều:
Bạn cũng có thể tạo một mảng của các mảng, hay là mảng 2 chiều bằng cách đưa 1 mảng vào thành phần tử của các mảng khác.
Trong trường hợp này, các hàm Array với loại mảng này sẽ có 2 tham số đầu vào (hoặc ra): X Index và Y Index. Ví dụ hàm Index Array.

3. Cluster:
Cluster là kiểu giá trị do người dùng quy định, tương tự như kiểu Structure trong lập trình C.
Với Cluster, người dùng có thể tạo một kiểu biến là tổng hợp của nhiều kiểu biến cơ bản. Ví dụ:
Kiểu biến có tên Sinh viên, với các thuộc tính con:
• Tên: Dũng (kiểu String)
• ID: 01 (Numeric Integer)
• Tuổi: 25 (Numeric Integer
• Ngày tháng năm sinh: 01-01-1987 (string)
• Điểm TB: 8.2 (Float)
Để tạo kiểu biến Cluster, ta làm như sau:
Tương tự cách tạo Array như trên, nhưng trong mục Array, Matrix, Cluster, ta chọn Cluster
Tạo các biến điều khiển dạng Numeric Integer, String, Float và đưa vào trong khối Cluster trông vừa chọn
-Trong Block Diagram, chọn Cluster vừa tạo, ấn chuột phải, chọn Creat >> Indicator, một Cluster mới dạng Indicator (hiển thị) được tạo ra và nối với Cluster Student trước đó. Cluster mới đặt tên là Student Indicator
-Chạy chương trình, toàn bộ thông tin từ Student đã được chuyển sang Student Indicator
- Để tách các thuộc tính con bên trong Cluster Student vừa tạo, ta trở lại Block Diagram, chọn biến Cluster Student, ấn chuột phải, chọn Cluster, Class, Variant Pallete >> Unbundle by Name

Ấn vào khối Unbundle by Name vừa tạo, hoặc kéo ra thêm các thuộc tính con để lựa chọn như trong hình trên, ta có thể trích ra các thuộc tính con của Cluster Student. Chạy chương trình ta thấy các giá trị trích ra đã được hiển thị:

(hết bài 2 )
... Bài tiếp theo: Bài 3: Vòng lặp While , Shift Register, Feedback node và Local Variable

[setwon]

Bài 2: Array và Cluster (Đỗ Trung Hiếu - CYBERLAB JSC.)

Array (Mảng dữ liệu) và Cluster (bó dữ liệu) là 2 khái niệm cơ bản rất quan trọng trong lập trình LabVIEW.

1. Array: Mảng dữ liệu:

Array hay mảng dữ liệu là khái niệm chỉ tập hợp hữu hạn được đánh số (index) các giá trị có cùng kiểu dữ liệu. Ví dụ: Mảng số thực, mảng số nguyên, mảng ký tự, mảng giá trị logic, mảng của mảng (mảng đa chiều), mảng đối tượng…
Để tạo 1 mảng các biến điều khiển/hiển thị, thực hiện theo thao tác sau:
Trên Front Panel, click chuột phải, chọn : Modern -> Array, Matrix & Cluster -> Array


Sẽ tạo ra một biểu tượng Array trống (Empty Array - Array chưa có phần tử hay quy định kiểu phần tử.

Để quy định kiểu phần tử vào mảng, chọn một Control hay Indicator bất kỳ bằng cách click chuột phải vào Front Panel, rồi di vào bên trong ô Array trống vừa tạo.
Ví dụ ta được một Nummeric Array (mảng số)

Đánh dấu đỏ là chỉ số của mảng.
Để tạo thêm thành phần (element) cho mảng, ta nhập giá trị vào mảng.
Bạn có thể tạo một mảng với kiểu giá trị bất kỳ: Số, số nguyên, số FLOAT, chuỗi ký tự, giá trị logic, Cluster, mảng các mảng, đường dẫn file,…Xem ví dụ dưới đây:

Ví dụ này mô tả nhiều dạng Array có thể được tạo trong LabVIEW: mảng Numeric, mảng Biến Logic điều khiển (dạng nút bấm), mảng biến logic hiển thị (dạng đèn Led), mảng String, mảng biến Numeric dạng Slide Bar (thanh trượt), mảng biến Numeric dạng Tank (bình chứa).
Xem Front Panel:

Trong ví dụ, tôi nối dây giữa các đầu vào Logic Control Array và Slide Bar Array với đầu ra Logic Indicator Array và Tank Array. Chạy chương trình (nút Run mũi tên) ta có kết quả như hình trên.
Quay trở lại Block Diagram, ta nhận thấy các đường dẫn tải dữ liệu dạng Array cũng có màu biểu thị kiểu dữ liệu mà nó mang (màu xanh lá cho kiểu Logic, và màu Da cam cho kiểu Numeric Float), nhưng có sự khác biệt về độ dày. Đường mang dữ liệu Array có độ dày hơn đường mang dữ liệu đơn giá trị thông thường.
...(còn tiếp)

[setwon]

• Các phép toán Logic

• Các phép toán với Mảng
• Các hàm với Chuỗi ký tự
• Các hàm toán học phức tạp: Lũy thừa, Logarit, hàm lượng giác, hàm với các Ma trận, hàm nội suy, hàm tối ưu

• Và nhiều khối hàm khác

Bạn cũng có thể gọi một chương trình bên ngoài, viết bằng C hoặc Matlab…

Đặc biệt, bạn có thể tạo 1 chương trình con để có thể gọi lại trong các chương trình về sau, hoặc để làm gọn chương trình chính. Một chương trình con trong labVIEW gọi là SubVI.

Để thực thi một phép toán trong LabVIEW, bạn đơn giản nối các tham số vào đầu vào của khối hàm, và nối đầu ra. Xem các ví dụ dưới đây:

Các bạn chú ý: đầu vào của các khối hàm thường là các biến Điều khiển (Controls), đầu ra thường là các biến Hiển thị (Indicators).
Mặc dù việc lập trình trong LabVIEW khá tự do theo bất cứ hướng nào, trình tự nào, nhưng các hàm thường được thực thi theo hướng từ trái sang phải. Vì thế khi lập trình trong LabVIEW, ta nên chú ý sắp xếp chương trình theo hướng đó để đảm bảo sự thống nhất trong chương trình, tiện lợi cho việc theo dõi, debug về sau.
Đến đây ta tạm thời kết thúc phần tìm hiểu các Khái niệm trong LabVIEW. Tất nhiên còn rất rất nhiều khái niệm khác mà tôi chưa thể trình bày hết ra đây, nhưng như vậy cũng tạm đủ để chúng ta tiếp tục tìm hiểu các khái niệm và thuật toán cao hơn, tiến tới lập trình một chương trình hoàn chỉnh.
Sau này, khi có các khái niệm mới, tôi cũng sẽ bổ sung thêm trong các bài bổ sung, hoặc trong chính mục Khái niệm này.
Cảm ơn các bạn đã theo dõi, hẹn gặp lại trong bài tiếp theo:
Bài 2: Array và Cluster.

[setwon]

... (tiếp bài 1)

5. Các phép toán trong LabVIEW:

Như ta đã biết, trong LabVIEW nội dung chương trình được thiết lập trong Block Diagram.
Bạn có thể tìm thấy các thư viện hàm để thực thi các thuật toán từ đơn giản đến phức tạp bằng cách: Ấn chuột phải, chọn mũi tên (như hình vẽ) và chọn Programming (để chọn các khối hàm cơ bản) hoặc chọn các khối hàm nâng cao hơn (ví dụ như khối Mathematics)


LabVIEW là một môi trường lập trình cực kỳ đa dạng cho phép ta có thể thực thi gần như bất cứ phép toán, thuật toán nào với rất nhiều kiểu biến, ví dụ:
• Các phép toán cơ bản: Cộng, Trừ, Nhân, Chia, Cộng 1, Trừ 1, Bình phương, Đảo dấu, Hàm Random, Dịch bit, ….

• Các phép so sánh

[setwon]

Bài 1: Điều khiển, Hiển thị và các Khái niệm cơ bản

(Tác giả: Đỗ Trung Hiếu - CYBERLAB JSC.)

1. Giao diện LabVIEW

Đây là giao diện ban đầu khi khởi động chương trình LabVIEW.
Từ đây các bạn có thể tạo một chương trình ban đầu (Blank VI), tạo một project trống (ấn vào Empty Project), tạo một chương trình theo mãu (VI from Template), hoặc nhiều lựa chọn khác. Bạn cũng có thể mở một chương trình có sẵn (Browse)




2. Chương trình của LabVIEW: VI hay là Virtual Instruments

Chương trình cơ bản của LabVIEW là một VI, hay là Virtual Instruments: Thiết bị ảo.
Để tạo 1 chương trình mới, ta ấn vào nút Blank VI. LabVIEW sẽ hiện ra 2 cửa sổ: Front Panel và Block Diagram.

Đó là 2 thành phần cơ bản của LabVIEW.

Front Panel (từ đây gọi là FP) là giao diện của chương trình với người dung. Tại đây lưu trữ
• Các Biến điều khiển như: nút bấm (Button), thanh gạt (Slide), Núm vặn (Knob), TextBox để nhập chuỗi ký tự… được gọi chung là các biến điều khiển, nơi người dùng có thể điều chỉnh giá trị của các biến đó bằng tương tác trực tiếp với chương trình
• Các Biến hiển thị: Đồng hồ (Meter), Đồ thị (Chart), Biểu đồ (Graph), đèn báo (LED), hình ảnh (Picture) hay hình ảnh 3D (3D picture)…gọi chung là các biến hiển thị, nơi người dung có thể quan sát thay đổi của các biến một cách trực quan.
• Các biến điều khiển và các biến hiển thị không có sự phân biệt rõ ràng trong LabVIEW, ngoài hướng tương tác với người dùng và với máy tính. Trong LabVIEW coi 2 loại biến này đều là các biến, có thể được lập trình để thay đổi trực tiếp
• Mỗi khi tạo 1 Biến Điều khiển hoặc Hiển thị trong Front Panel (FP), một biểu tượng (Icon) sẽ xuất hiện tương ứng trong Block Diagram (BD). Kích đúp vào Biến trên FP, Icon tương ứng trong BD sẽ được tự động biểu hiện.
• Mũi tên được đánh dấu là nút RUN, dùng để bắt đầu chạy chương trình. Khi nút RUN đó bị gãy, tức là chương trình đang có lỗi (Error), không chạy được

Block Diagram (DB) : Là nơi chương trình LabVIEW được lập trình, chứa nội dung (code) chương trình.
• Tương tự trong Simulink của Matlab, việc lập trình trong DB bằng cách nối các biến với nhau và với các khối biểu diễn phép toán giống như đi dây trong thiết bị điện.
• Trên Block Diagram cũng biểu diễn các vòng lặp, Cấu trúc lập trình, và các thuật toán.
• Khi chương trình VI chạy Block Diagram không hiển thị giao diện tương tác với người dùng.
• Có thể chạy chế độ Debug trên Block Diagram bằng cách ấn vào biểu tượng Bóng đèn trong BD (Highlight Execution). Các dòng dữ liệu sẽ được biểu diễn chạy tuần tự để biểu thị sự thay đổi chi tiết các biến trong chương trình
• Để tạo ra một chương trình sáng sủa, gọn gàng nhằm đơn giản hóa việc kiểm tra, kiểm soát chương trình, một chương trình LabVIEW thông thường được lập trình theo trình tự: Từ trên xuống dưới, trái sang phải.

3. Tạo project LabVIEW

Để tạo 1 Project trong LabVIEW, ta ấn vào Empty Project. Trong các bài viết tiếp đây chúng ta hầu như làm việc bằng cách tạo Empty VI, việc tạo Project là chưa thực sự cần thiết.

4. Các kiểu dữ liệu cơ bản trong LabVIEW

Trong LabVIEW có nhiều kiểu biến: Biến số (Numeric), Biến ký tự (String), Biến Mảng, Biến Cluster, Biến Logic (Boolean)…

Mỗi biến được phân biệt bằng các màu trong Block Diagram. Ví dụ:
• Kiểu Numeric dạng Float (số 64 bit dấu phảy động) là kiểu biến có dải giá trị lớn nhất, với độ chính xác cao nhất nhưng tốn nhiều dung lượng chương trình nhất, biểu diện bằng màu vàng da cam
• Các kiểu Numeric Integer: Int8, Int16, Int32, Int64 (số nguyên 8, 16, 32, 64 bit) và U8, U16, U32, U64 (số nguyên không dấu 8,16,32,64 bit) được biểu diễn màu xanh da trời
• String: Chuỗi ký tự, biểu diễn màu hồng
• Boolean : Kiểu Logic, là kiểu biến cho các nút bấm, đèn led và các giá trị logic khác, biểu diễn bằng màu xanh lá cây
(Còn tiếp)...

[setwon]

Chào các bạn
LabVIEW ngày nay đang dần trở nên quen thuộc với những người làm Kỹ thuật ở Việt Nam. Cùng với đó là ngày
càng nhiều các tài liệu hướng dẫn lập trình LabVIEW bằng tiếng Việt lẫn tiếng Anh đang ngày càng trở nên phổ
biến và phong phú.
Mình cũng xin giới thiệu với các bạn một bộ tài liệu khác của công ty Cyberlab biên soạn để cung cấp miễn phí cho
các khách hàng là Sinh viên và người đi làm, đi kèm với ví dụ rất cụ thể và trực quan. Các tài liệu này được biên
soạn từ những khóa đào tạo LabVIEW của Cyberlab cho các học viên và khách hàng sử dụng sản phẩm của công ty,
nay được phổ biến miễn phí cho mọi người.
Tóm tắt nội dung:
Bài 1: Khái niệm căn bản
Bài 2: Array và Cluster
Bài 3: Vòng lặp While, Shift Register, Feedback Node và Local Variable
Bài 4: Vòng lặp FOR và thủ thuật với Array
Bài 5: Cấu trúc Case, Sequence và Event. Khái niệm Lập trình State Machine
Bài 6: String và lưu trữ File
Bài 7: Lập trình theo tư duy State Machine (Máy trạng thái)
Bài 8: Lập trình giao tiếp RS232 và USB. Giới thiệu thiết bị thu thập dữ liệu DAQ và Card EasyDAQ U1001 của
Cyberlab
Bài 9: Lập trình giao tiếp TCP/IP trong LabVIEW
Bài 10: Giao tiếp LabVIEW với chương trình ngoài. Tích hợp lập trình C trong LabVIEW
Bài 11: LabVIEW với Active X và dotNet
Bài 12: Lập trình tư duy trạng thái (nâng cao) với Event Structure và Queues
Ngoài ra các bạn cũng có thể tìm hiểu LabVIEW chuyên sâu trong các lĩnh vực: Mô phỏng 3D, Lập trình với Cơ sở
dữ liệu MySQL, Mô phỏng và Điều khiển động cơ điện 1 chiều
Nếu có câu hỏi gì bạn có thể liên hệ:
website: Cyberlab
email: info@cyberlab.com.vn
Rất mong góp chút công sức để giúp các bạn học LabVIEW được dễ dàng và nhanh chóng hơn.
Chúc các bạn thành công và tìm được nhiều niềm vui trong đam mê kỹ thuật!