An Effective Concept for Teaching LabVIEW Programming to Engineering Students

Abstract

In today’s technology-driven era, the demand for engineers with strong programming skills continues to rise across diverse industries. LabVIEW software stands out as a key tool in engineering, supporting applications ranging from test and measurement systems to automation and control across different sectors, like manufacturing, aerospace, and automotive. Proficiency in LabVIEW therefore enables engineers to work on a wide range of projects and applications. This article presents two distinct pedagogical approaches to teaching LabVIEW programming at the university level. The introductory course is taught using traditional direct teaching methods, with an emphasis on face-to-face teaching and classroom lectures. In contrast, the advanced course uses a flipped classroom model, where students work independently on preparatory material before participating in laboratory exercises. The latter course concludes with a large project, which the student must complete within four hours. The article provides details on the teaching methods and content of the individual courses, as well as an explanation of the assessment process for the final project. The analysis of the final project results confirms that the students have acquired the knowledge necessary to create functional LabVIEW programs with the appropriate programming style.

1. Introduction

In an era when technology is an integral part of almost every industry, the demand for qualified engineers with strong programming skills is increasing constantly. With the ability to write algorithms and develop logical solutions, engineers can solve a wide range of engineering challenges, from designing new systems to optimizing existing processes. Programming skills empower engineers to customize solutions to meet specific requirements and optimize performance. Therefore, investing the time and effort to acquire in-depth programming skills for engineering professionals represents a wise decision that can bring significant personal, professional, and societal benefits. In the engineering field, LabVIEW™ (Laboratory Virtual Instrument Engineering Workbench) software is used widely across different industries, including manufacturing, research, aerospace, automotive, and more. Numerous engineering tasks involve data acquisition from a variety of sensors and instruments. LabVIEW provides extensive libraries and drivers for interfacing various hardware devices, such as sensors, instruments, and industrial equipment. Proficiency in LabVIEW allows engineers to work on a wide range of projects and applications, from test and measurement systems to automation and control, which makes them more competitive in the labor market.

LabVIEW is an integrated development environment (IDE) for the graphical programming language G developed by National Instruments (NI). LabVIEW was introduced in 1986 as a tool that allows non-programmer scientists and engineers to create customized programs for their test and measurement systems quickly and easily [1]. As it has evolved, it has become a productive graphical programming environment used widely in industry [2,3,4], research [5,6,7,8], and teaching [9,10]. The reasons for its popularity are (1) the excellent support with software drivers for a wide range of measurement hardware, (2) the comprehensive set of analysis functions, and (3) the simple design of the graphical user interface (GUI) for the target applications. A further extension of its functionality is achieved with software add-ons such as LabVIEW Real-Time [11], LabVIEW FPGA [12,13], Vision Development Module [14,15,16], G Web Development Software [17], and many others. A software module developed in LabVIEW is called a virtual instrument (VI). It consists of a front panel, a block diagram, and an icon/connector pane. The front panel represents the graphical user interface of the VI, the block diagram defines the algorithm of the operation, and the icon/connector panel enables a modular and hierarchical structure of the application.

In education, LabVIEW is used most often for the development of hands-on, virtual, and remote laboratories [18,19,20,21,22]. Remote laboratories are typically applied in engineering disciplines such as control [23,24,25,26,27], instrumentation and measurement [17,28,29,30], electronics [31,32,33,34], mechatronics [35], and robotics [36]. In these cases, LabVIEW has been selected for developing the measurement server because of its extensive software support for hardware and communication protocols. In traditional laboratory exercises, teachers use LabVIEW to prepare and conduct laboratory experiments in a variety of engineering [37,38,39,40] and natural science [41,42,43,44] subjects. It allows them to develop affordable laboratory experiments [37,45,46] and to create an easy-to-understand GUI that is tailored to the learning content [39,40,47,48,49]. This increases students’ interest [50] and improves their understanding of the theory [40,42,44].

In remote laboratories and laboratory experiments, students can change the parameters of experiments on a predefined GUI, but they do not learn how to program such LabVIEW applications. In contrast, this paper presents pedagogical approaches to teaching LabVIEW programming at the undergraduate level. LabVIEW supports various architectural patterns, such as an event-driven state machine or producer/consumer architectures. In-depth knowledge of architectural patterns is crucial for students to be able to select the most appropriate design pattern for their specific application requirements. Detailed knowledge of LabVIEW thus improves the overall robustness and maintainability of the developed application. In the presented solution, LabVIEW programming methods are discussed in two undergraduate courses. The students are introduced to LabVIEW and taught the basics of graphical programming in the first study year. This is achieved using traditional face-to-face teaching blended with e-learning and an in-house developed data acquisition device (DAQ) [51]. In the second study year, the students learn advanced programming techniques and styles. In this case, the teaching methods are based on the flipped classroom and the project approach. In this way, students acquire sufficient knowledge of LabVIEW programming, which they can apply and improve in various projects and their final thesis.

The remainder of the paper is organized as follows. Section 2 introduces related work regarding the teaching and learning of LabVIEW programming. Section 3 presents our approach to teaching LabVIEW programming at the undergraduate level and the teaching methodologies used. Section 4 presents and discusses the results of the students’ assessment, while Section 5 provides a conclusion.

2. Related Work

Graphical programming in LabVIEW is based on a dataflow programming model and provides a more intuitive experience than conventional scripting languages. Graphical representations are also a more natural design notation for engineers and scientists than text code. As a result, most students learn to program more easily and quickly with LabVIEW than with traditional programming languages. For this reason, it is often used by teachers in project-based learning (PBL) [52].

A PBL approach to teaching a hardware-based controls laboratory that allows students to be in charge of all the programming required for the course has been presented in [53]. The students were given concise tutorials on graphical programming and then had to write the code themselves. The authors found that the students were more involved in the course and provided more creative solutions to problems than in a course where the software was pre-written.

The learning experience and research interest of undergraduate technology students have been enhanced with LabVIEW [54]. The author found that the design and development of LabVIEW programs stimulated students’ interest and enthusiasm in the automation topics delivered in lecture sessions. The students were also introduced to high-level research projects involving LabVIEW, which were carried out by academics. Exposure to research has encouraged and motivated students to explore the subject of automation further in the context of masters’ and doctoral studies.

An adjustable speed drive for a three-phase motor implemented as a design for a servo system laboratory course in an engineering curriculum is described in [55]. The platform is controlled and analyzed in LabVIEW and runs on a PC. The project is carried out following guided instructions. After a short introduction to LabVIEW, the students create the GUI for analysis and tuning. For the students who needed more help, the NI LabVIEW Basics I: Introduction Course Manual was made available.

The effectiveness of using LabVIEW to learn the Modbus digital communication protocol was discussed in [56]. Two LabVIEW-based Modbus communication projects were created for an instrumentation course, while five laboratory classes were created to support the course projects. In these projects, the students learned LabVIEW, data acquisition, instrumentation, and the Modbus communication protocol. During the student projects, the authors observed that laboratory classes should be tied to student projects. In this way, the students were better prepared for the projects. Otherwise, many students may be unable to complete the projects on time.

The impact of blended learning on LabVIEW certification success was studied in [57]. A traditional course was blended with e-learning to enhance the students’ programming skills. The need to complete projects and the wish to succeed in the certification exam motivated students to use e-learning outside the classroom. This case study showed that the students who used e-learning scored much higher on the certification exam than those who only had face-to-face learning experiences.

The integration of virtual instrumentation in the development of engineering projects in undergraduate electrical engineering education was introduced in [58]. The concept of virtual instrumentation is to combine different hardware and software components to create customized systems for testing, measurement, and industrial automation. Students learn about the principles of virtual instrumentation through project work and the use of LabVIEW. The evaluation of the student surveys showed that the students were satisfied with the projects implemented using LabVIEW because it reduced the difficulty and time needed to complete the project.

Graphical programming using LabVIEW has frequently been applied to project-based learning using mobile robots. Laboratory work and student competitions based on LabVIEW and the LEGO™ Mindstorms NXT mobile robot kit were combined successfully in [59]. The teachers observed high student motivation, with the competitions driving their interest in learning. Instead of the default NXT Education software, programs were developed using standard LabVIEW. The same mobile robot kit and software were also used in the laboratory exercises to learn fault detection and the diagnosis of mechatronic systems [60]. A more powerful and versatile mobile robotic platform based on a real-time processor and field-programmable gate array (FPGA) was used in challenging projects to learn autonomous driving algorithms [12,61,62]. The flipped classroom approach with LabVIEW and the NI myRIO device has been employed successfully to reconstruct the mechatronic systems curriculum [63].

Graphical programming has also been used successfully by several educators in the teaching of physics to undergraduate students [64,65,66]. Their studies showed that most physics students found graphical programming easier than traditional text-based programming, and that using LabVIEW increased their motivation for programming.

In the presented approaches, the students learn LabVIEW programming, but there is no emphasis on programming techniques and code quality. Their block diagrams are mostly not modular and do not follow established software design patterns, and would therefore need to be refactored [67]. In our approach, we introduce the students to the basics of LabVIEW programming in their first year and then teach them more advanced programming techniques in their upper years. To assess their knowledge in the first year, we apply a quiz, while in the second year, the students are given a time-limited project task that they must be able to solve themselves using standard software design patterns.

To evaluate the effectiveness of our teaching methods, we aim to achieve the following research goals:

• To identify advantages and disadvantages of face-to-face and flipped classroom learning approaches on students’ understanding of LabVIEW programming concepts.
• To assess the quality of LabVIEW code produced by students using described teaching methods, focusing on factors such as functionality, usability, modularity, readability, and maintainability.

3. Teaching Methodology

The Faculty of Electrical Engineering and Computer Science at the University of Maribor (UM FERI) offers Bologna academic and professional higher education study programs. All bachelor (first cycle) Bologna studies last three years (six semesters). LabVIEW is used for experimental laboratory work in several subjects and therefore, the decision was made to integrate LabVIEW into the laboratory work of the Electrical Measurements course. The Electrical Measurements course is compulsory for the Electrical Engineering and Mechatronics study programs and represents a basis for all subsequent laboratory exercises. This course aims to provide the students with basic knowledge about instrumentation and measurement. The course takes place in the first semester for professional higher education study programs, while, for university study programs, it takes place in the second semester. About 120 students in professional higher education and 100 students in university study programs perform laboratory work yearly. The Electrical Measurements course contains 40 h of laboratory work, including 12 h of the hands-on Introduction to LabVIEW course. To reach laboratory capacity, we need to start laboratory work at the beginning of the semester when the students start attending lectures. To fill the gap in theoretical knowledge, the laboratory work starts with an introductory hands-on LabVIEW course, which lasts six weeks. After the LabVIEW course, the students continue with traditional measurement exercises. During the LabVIEW course, the students obtain basic knowledge about virtual instrumentation, which allows us to supplement traditional exercises with virtual instrumentation. Some exercises are prepared with classical instrumentation and virtual instrumentation in parallel to demonstrate the difference.

The study programs in electrical engineering at UM FERI are divided into different study options in the second year. The Standardization and Quality Assurance (SQA) course is taught in the third semester of the professional higher education study program in Electrical Engineering in the Automation and Robotics option. This course is compulsory for Automation and Robotics students and includes 30 h of laboratory exercises. Part of these laboratory exercises is intended to extend the Introduction to LabVIEW course and teach more advanced LabVIEW programming techniques.

3.1. Introduction to LabVIEW Course

The Introduction to LabVIEW course introduces students to the LabVIEW development environment, graphical user interface design processes, and algorithm creation procedures. The students are introduced to different programming structures (for loop, while loop, sequence), arrays, the procedures for saving data to files, and LabVIEW’s data-driven principle of operation. LabVIEW follows a dataflow paradigm, where code execution occurs based on the availability of data on the input terminals of nodes. When all the required inputs of a node are available, it executes and produces output data, which can then trigger subsequent nodes to execute. Data-driven flow ensures that computations occur only when the necessary data are available, optimizing performance and resource utilization. During the course, the students become familiar with graphical programming based on the dataflow programming model and learn how to perform the following tasks:

• Create a front panel, block diagram, and icon/connector pane;
• Use various editing and debugging techniques;
• Use built-in functions;
• Create and save LabVIEW programs and use them as subroutines (subVIs);
• Use the programming structures and different data types;
• Display and log measured data;
• Create applications that use a DAQ device.

Emphasis is placed on the modular design of the LabVIEW programs. Modular design enhances the organization of LabVIEW applications by decomposing complex algorithms into smaller, manageable modules or subVIs. Each subVI performs a specific function, simplifying the understanding and maintenance of the entire application’s architecture. In addition, the modular design enables code reusability. Well-designed subVIs that contain commonly used algorithms can be integrated easily into several parts of an application or even reused in different projects. The modular design also simplifies testing and validation processes. Each subVI can be tested independently to ensure that its functionality meets the requirements. LabVIEW supports various architectural patterns, such as an event-driven state machine or producer/consumer architectures, which are covered in the Advanced LabVIEW course.

The Introduction to LabVIEW course is integrated into the Electrical Measurements course and starts in the first week of the semester with a two-hour introductory classroom meeting. In this first meeting, the students are introduced to the course and the use of the university’s learning management system (LMS). The University of Maribor (UM) has implemented an LMS based on the free and open-source Moodle platform. It serves as the primary source of information for the course and offers many different services to the students; among them are the following:

• Primary information about the course and the contact information of the professors and assistants;
• Contents of lectures with lecture notes;
• Laboratory work material and laboratory schedules;
• Knowledge tests with quiz activities;
• Exchange of documents, group mailing, and a discussion forum.

During this general introduction, the students are shown how to create an account on the NI website and register for the NI Student Install Option. This license allows the students to download and install the same software as we have at UM on their personal computers and gives them access to almost all online courses within the NI Learner Dashboard platform. Afterward, they are guided through the installation and activation process of the LabVIEW software and introduced to the NI LabVIEW Core 1 online course. Introduction to LabVIEW is based on custom-developed learning material in the Slovene language, available to the students in the LMS, as seen in Figure 1. At the same time, the NI LabVIEW Core 1 online course is also available to the students, which is meant as supplementary learning material.

The following two-hour session in the second week also takes place in a classroom. This lecture presents the concept of virtual instrumentation and its components, among which software is essential. The LabVIEW graphical programming environment is presented with a combination of slides and directly in the program. The structure of the virtual instrument and dataflow programming model are explained and demonstrated.

After these introductory lectures in the classroom, the course continues for the next four weeks in the laboratory. The laboratory work is organized in groups of ten students, guided by a teacher and an assistant. Two groups of students are in the laboratory at the same time. The laboratory work of the Introduction to LabVIEW course is divided into four lessons, each covering a set of topics, as shown in

Table 1. Introduction to LabVIEW laboratory work outline.

Week (Duration)	Lesson	Topics
1. (2 h)	Virtual Instruments (VIs)	Creating, Editing, and Debugging a VI Creating a SubVI Documenting a VI
2. (3 h)	Programming Structures	Loops and Charts Timing a Loop Shift Register Case Structure Sequence
3. (3 h)	Working with Data	Arrays and Graphs Clusters Strings and File I/O
4. (4 h)	Data Acquisition with SimpleDAQ	SimpleDAQ Device Analog Inputs Digital I/O Temperature Control Application

. The teacher first explains the topic and then the students complete a related practical activity. The students work through the exercises using a printed manual, which is also available to them electronically via the LMS. This allows them to repeat the exercises at home or look at practical software solutions. Beside the assignment’s text, the manual provides a front panel and a block diagram with guided instructions for each exercise. In addition to these teacher-led exercises, the students must complete homework at the end of each session. The homework definition does not include block diagrams, so the students must find their own program solutions.

The exercises complement each other and are designed as a small project, resulting in a temperature control application. In the first week, the students make a simple VI to convert the temperature scale from Celsius to Fahrenheit and create an icon and connector pane. This VI is then used as a subVI in a thermometer VI, where the voltage measurement of the temperature sensor is simulated. Simulating the measurements in the initial part of the exercises avoids hardware, which allows the students to repeat the exercises at home and makes the simulated temperatures more dynamic. They also make an icon and connector pane for the thermometer and then document it. This gives the students an early introduction to modularity and documentation, which are the basis for creating clear and understandable block diagrams. In the second week, the students are introduced to programming structures. They use the thermometer from the first part of the exercises to create a VI for displaying the temperature history on a waveform chart. During this activity, the students learn how to use while loop timing functions to control the loop execution rate and chart properties. This is followed by explaining the shift registers and an example of their use by extending the previous VI with an additional plot on a waveform chart with the average of the last three temperature values. In the last part of this exercise section, case structures are explained to the students and then they implement the on–off temperature control. In the third week, the students learn about data arrays, clusters, and strings. They perform specific exercises for each topic to learn how to use common functions for working with data and display data arrays in a graph. Afterward, working with files is explained. The students upgrade the VI for temperature control by saving the time and measured temperatures in a text format suitable for import into a spreadsheet. After these three weeks and eight hours of laboratory work, the students learn the basics of LabVIEW programming and build a VI for temperature control, the block diagram of which is shown in Figure 2.

The laboratory work in the fourth (last) week takes four hours and is dedicated to data acquisition with the SimpleDAQ device. SimpleDAQ is an in-house developed microcontroller-based data acquisition device with preloaded custom-developed firmware and a LabVIEW instrument driver [51]. It enables the easy acquisition of analog signals, digital input/output, PWM output, a serial peripheral interface (SPI), and USB data transfer between the device and the LabVIEW application running on a PC. An additional application board has been developed for SimpleDAQ which contains a programmable waveform generator, LED indicator, analog temperature sensor, and a heating element (resistor) that is placed above the sensor, as seen in Figure 3. The output of the temperature sensor is connected to pin 2 of the SimpleDAQ device and configured as an analog input. In contrast, pin 21, configured as a digital output, turns the LED and heating on/off.

At the beginning of the exercises, the students are introduced to the SimpleDAQ device and the application board. Their main features are highlighted and their operation is explained using electrical circuits. Then, an overview of the LabVIEW driver for SimpleDAQ and examples of its use are given. After this introductory presentation, the students complete four exercises, including measuring the voltage of a temperature sensor and making a thermometer, setting and acquiring the signal at the output of a function generator and an LED toggle switch. The exercise material provides instructions on front panels and block diagrams for these tasks.

The final task requires the students to redesign the temperature control application with the temperature measurement simulation shown in Figure 2 using a SimpleDAQ device to control the temperature of a heating resistor on an application board. In this task, only the front panel shown in Figure 4 is given to the students and therefore, the students are challenged to find a suitable solution based on their acquired knowledge. Figure 5 shows an example of a possible solution to this problem. This completes the Introduction to LabVIEW hands-on course, and the students continue their laboratory work with traditional exercises in electrical measurements.

3.2. Advanced LabVIEW Course

The primary purpose of the advanced LabVIEW course is to provide the students with advanced topics, like state machines, the creation of event-driven user interfaces, parallel code execution, NI DAQ device driver usage, etc. State machines provide a clear and structured way to organize the behavior of LabVIEW applications. Each state represents a specific mode or condition in which the system can be. State machines encourage modularity by dividing complex behaviors into manageable states and transitions. State machines are beneficial because they enable better code organization, increase modularity and reusability, improve maintainability, support event-driven programming paradigms, handle errors effectively, and allow comprehensive testing and validation in software development.

The LabVIEW event-driven architecture allows user interfaces to be highly responsive. Events such as button clicks, mouse movements, or keyboard inputs trigger specific actions immediately. Events can be handled asynchronously, meaning that different program parts can respond to events independently. This capability is crucial in applications where simultaneous data acquisition, processing, and user interaction occur.

The Advanced LabVIEW course is integrated into the laboratory exercises of the Standardization and Quality Assurance (SQA) course. The number of students varies from year to year due to the electivity of the study option. Therefore, laboratory exercises are usually carried out in one or two groups, with a maximum of sixteen students per group. Due to the limited laboratory hours, the course has been designed as a flipped classroom to improve student engagement. This is achieved using the NI LabVIEW Core 1 and Core 2 online courses available to students within the NI Learner Dashboard platform. Every week, the students are instructed on which video lectures to watch at home to prepare for the next laboratory session and then complete practical exercises in the laboratory following the instructions in the exercise guide. The teacher’s primary concern is supporting the students with questions and clarifications to improve their understanding of the concepts.

The course runs for eight weeks, with two hours of laboratory work per week and then ends with a four-hour assessment project, as shown in

Table 2. Overview of the LabVIEW advanced course.

Week	Lesson	Topics
1.	Measurement with an NI DAQ Device	Overview of an NI USB-6001 DAQ Device Connecting and Testing an NI USB-6001 Analog I/O with an NI USB-6001
2.	LabVIEW Core 1—Part 1	Writing and Reading Data to Files Controlling Data Type Changes
3.	LabVIEW Core 1—Part 2	Implementing a Sequencer
4.	LabVIEW Core 2—Transferring Data	Communicating between Parallel Loops Exploring and Using Channel Wires Transferring Data Using Queues
5.	Creating an Event-Driven User Interface	Event-Driven Programming User Interface Event Handler Design Pattern Event-Driven State Machine Design Pattern Producer/Consumer (Events) Design Pattern Channeled Message Handler (CMH) Design Pattern
6.	Controlling Front Panel Objects, Managing Configuration Settings	VI Server Architecture Property Nodes and Invoke Nodes Configuration Settings Overview Managing Configuration Settings Using an Initialization (INI) File Homework: Event-Driven State Machine
7.	Error Handling Strategy	Error Handling Overview Injecting Errors and Exploring Error Response Exploring Event Logging Homework: Example of a Final Project
8.	Distributing LabVIEW Code	Preparing Code for Distribution Creating and Debugging a Stand-Alone Application Creating a Package for Distribution Reviewing Exemplary Final Project Solutions
9.	Assessment Project	Four-Hour Assessment Project

. Before the beginning of the exercises, the students are encouraged to refresh their knowledge from the first year and to watch the interactive LabVIEW Core 1 course. At the beginning of the laboratory work in the first week, the students are introduced to the NI USB-6001 multifunction DAQ device, which they then use to make a voltmeter and a voltage ramp generator. The students learn how to use the DAQ Assistant Express VI to configure common measurement tasks interactively and how to generate NI-DAQmx code. Over the next two weeks, the topics of LabVIEW Core 1 that were not addressed in the Introduction to LabVIEW course in the first year are now covered and then the entire LabVIEW Core 2 course is implemented. The LabVIEW Core 2 course is an extension of the LabVIEW Core 1 course and teaches the students how to use common design patterns to implement LabVIEW applications successfully. Preparation for the assessment project starts in the sixth week with a homework assignment in which the students make an Event-Driven State Machine exercise from the LabVIEW Core 2 Exercise Guide by creating a new project based on the Simple State Machine template and modifying it accordingly. Through this homework, the students learn the easiest and fastest way to build an application based on the Event-Driven State Machine design pattern template. In the seventh week, the students receive homework with an example of an assessment project from previous years, which they must complete by the eighth week. The project requirements and criteria for the evaluation are presented at the same time. During the laboratory exercises in the eighth week, their solutions are reviewed and commented on individually. An example of a correctly solved problem is then shown and discussed by the whole group. In the last week, the students work on a four-hour assessment project described in the next section.

Assessment Project

The assessment project at the end of the advanced LabVIEW course aims to check the students’ ability to create functional LabVIEW programs with an appropriate programming style and documentation. The examination takes place in the same laboratory as the course, where all workplaces have computers with the latest version of LabVIEW and all the necessary measurement hardware. The use of resources available in LabVIEW, such as LabVIEW Help and examples, are allowed during the examination, while externally developed VIs or resources are not allowed.

We have prepared a set of different projects where it is necessary to create a LabVIEW application in which it is required to perform the following:

• Use the event-driven state machine design pattern;
• Use type definitions;
• Handle errors;
• Use a timestamp in the file name;
• Set the properties of the front panel programmatically;
• Create a stand-alone application;
• Pay attention to the design and programming practices (modular structure with meaningful names and icons of subVIs, front panel design, code readability, and documentation).

An example of such a project is the creation of an application called “SQA DAQ test” that generates and acquires a waveform using SimpleDAQ and displays it in a graph. The graph must have scales with the correct units, legends for the scale and the plot, and a graph palette. In addition to the graph, the front panel should contain the controls and indicators listed in

Table 3. List of controls and indicators for the front panel of the “SQC DAQ test” application.

Type	Name	Properties	Description
Numeric Control	Sampling frequency (Hz)	Representation: DBL Minimum: 200 (Coerce) Maximum: 100000 (Coerce) Increment: 1 (Ignore) Default: 50000	The sampling frequency of the SimpleDAQ device.
Numeric Control	Number of samples	Representation: U16 Minimum: 10 (Coerce) Maximum: 1000 (Coerce) Increment: 1 (Ignore) Default: 200	The number of samples acquired with the SimpleDAQ device.
Boolean Control	Acquire	Latch When Released	Waveform acquisition button.
Menu Ring Control (Type Def.)	Signal type	Representation: U8 Items: Sine Wave (B2) Triangle Wave (B3) Square Wave (B4)	Control created from the input terminal of the SimpleDAQ “Configure Function Generator.vi”.
Numeric Control	Output frequency (Hz)	Representation: DBL Minimum: 10 (Coerce) Maximum: 20000 (Coerce) Increment: 1 (Ignore) Default: 1000	Output frequency of the SimpleDAQ function generator.
Boolean Control	Generate	Latch When Released	Waveform generation button.
Boolean Control	Log	Latch When Released	Waveform save button.
Boolean Control	Exit	Latch When Released	Exit application button.
Numeric Indicator	DC value (V)	Representation: DBL	DC value of waveform.
Numeric Indicator	RMS value (V)	Representation: DBL	RMS value of waveform.
File Path Indicator	Log file	File path	Log filename indicator.

. During the evaluation of the project assignment, it is checked whether the correct data types, ranges, and default values have been applied. Their placement, grouping, and alignment on the front panel are also assessed. The front panel should be designed using an appropriate color scheme without unnecessary colorfulness. An example of a suitable front panel design solution is shown in Figure 6.

The logical flow of the application is given by the state transition diagram shown in Figure 7. At initialization, the function generator should be set to a sinusoidal waveform with a frequency of 1 kHz. The front panel properties of the main application must be set programmatically to hide the menu bar, tool bar, and both sliders when the application is running. The close button in the title bar should also be disabled, and the front panel should be placed in the center of the screen. The “Log” button should be disabled and grayed out at initialization. This verifies that students know how to control the objects on the front panel using the Property Node and Invoke Node. After initialization, the state machine transits to the Wait for Event state. This state should contain an event structure that waits for front panel changes. When a user clicks a button, LabVIEW recognizes the event and switches to the appropriate sub-diagram of the event structure. This sub-diagram then initiates a transition to the appropriate state.

Table 4. Events and their corresponding state diagram logic.

Event	State Diagram Logic
“Acquire”: Value Change	Acquire the signal and display it on the graph, then enable the “Log” button. Afterward, analyze the signal by calculating the DC and RMS values using the “Basic Averaged DC-RMS.vi” function.
“Generate”: Value Change	Set the signal type and frequency of the generator, then acquire and analyze the signal.
“Log”: Value Change	Save the signal, then disable and gray out the “Log” button.
“Exit”: Value Change	Exit the application.

lists the events and their corresponding state diagram logic. The realization of this application requires the use of an event-driven state machine design pattern and type-defined data structures for state and data management. If this requirement is not met, the project is assessed to be unsuccessful.

By clicking on the “Log” button, the signal must be saved to a file using the “Export Waveform to Spreadsheet File.vi” function. The log file should be stored relative to the user’s documents folder in a subfolder named SQA DAQ project\Logdata. The system path to the user’s documents folder is returned by the “Get System Directory.vi” function. The name of the log file needs to be generated programmatically and contain a timestamp and a name in the format: SQA_log-YYYY-MM-DD_HHMMSS.txt (e.g.,: SQA_log-2024-07-05_101725.txt). The students are expected to make a subVI for the generation of the file path, thus satisfying the requirement for a modular structure of the application, as illustrated in Figure 8. Finally, the standalone application “SQA DAQ test” should be generated in the SQA DAQ project\Executable subfolder.

4. Results and Discussion

4.1. Results of Introduction to LabVIEW Course

Two weeks after the Introduction to LabVIEW course, the laboratory exercises begin with a 20 min LabVIEW quiz. The quiz is implemented in the university’s LMS as a Moodle quiz activity. It contains fifteen questions of multiple-choice type, covering the knowledge and understanding of the LabVIEW programming environment and the fundamentals of LabVIEW programming taught in the course. Figure 9 shows an example of the LabVIEW quiz questions. Similar questions were asked after each lesson during the course and are also included in the course material. A score of 50% or higher is required to pass the quiz. A passing grade in the quiz is a prerequisite for the end-of-semester defense of the laboratory exercises in electrical measurements. The results of the student success for the professional higher education study programs from the academic year 2021/2022 to 2023/2024 are shown in

Table 5. The results of student success in the Introduction to LabVIEW course for the professional higher education study programs.

	Number of Students Who:
Academic Year	Took the Assessment	Took the 1st Quiz	Passed the 1st Quiz	Took the 2nd Quiz	Passed the 2nd Quiz	Passed with Practical Tasks	Percentage of Successful (%)
2021/2022	100	98	54	42	21	22	97
2022/2023	100	100	60	34	21	13	94
2023/2024	97	97	55	35	22	12	92

. Between 55% and 60% of the students usually pass the quiz on the first attempt and therefore, we repeat it before the end of the exercises. To prepare for the second quiz, the students are advised to watch the lecture videos from the online NI LabVIEW Core 1 course, available as supplementary learning material, and are encouraged to contact us for any further clarifications or questions. Most students pass the quiz on their second attempt, but about 10% still fail. Not passing the quiz does not necessarily mean that the student does not have enough knowledge to solve the practical task using LabVIEW and thus, a different approach is taken in this case. Before attempting the defense of the laboratory exercises, they must complete the online NI LabVIEW Core 1 course and show a certificate of completion, which is generated automatically and saved in the NI Learner Dashboard platform after finishing the course. Then, at the beginning of the defense, they have 60 min to make four LabVIEW programs like the ones they had for homework. If they are successful, they can continue to defend the laboratory exercises in electrical measurements. Otherwise, they must repeat all the laboratory exercises in the following academic year. As a result of this approach, over the last three years, between 92% and 97% of students have passed the LabVIEW assessment and there have been no students repeating the first year who have not passed the electrical measurement laboratory exercises because they have failed the LabVIEW course.

In the academic years 2021/2022, 2022/2023, and 2023/2024, 95 out of 117, 82 out of 120, and 88 out of 107 students who enrolled in the laboratory exercises passed the defense of the laboratory exercises. The difference between the number of students enrolled in the laboratory exercises and the number of students who took the LabVIEW assessment is due to the drop-out rate typical for the first semester.

4.2. Results of Advanced LabVIEW Course

The results of the assessment project by different criteria for the academic years 2021/2022 to 2023/2024 are shown in Figure 10. During this period, 39 student projects were assessed against the criteria shown. Students satisfy a criterion if they meet all the project requirements related to that criterion. For the project organization, it was necessary to create the required file structure and to store the subVIs and controls in separate folders, which most students did. In the front panel design, some students did not group and align the objects on the front panel, or their size was inappropriate. Units were often missing from the graphs and default values or limits were not set for some controls.

All but two students used the event-driven state machine design pattern correctly. One student used polling instead of an event structure to handle UI events, while the other did not use the type-defined data cluster for data management. More than 80% of the students met the functionality and modularity criteria. A few students made a mistake in the implementation of the state transition, or their programs were broken due to incorrect reference types or were not completed fully. Error handling was implemented correctly by 72% of the students. All the students wired the error terminals correctly and used the error reporting function, but some did not close the communication with the SimpleDAQ device when exiting the application in the case of an error. The front panel initialization was performed fully by 67% of the students. Others had the most problems with setting the properties to hide the scrollbars, which is achieved using the property node linked implicitly to the front panel object “Pane”. When setting the properties for the “Log” button, the students often set only “Disabled” instead of “Disabled and Greyed Out”, or did not change this property after saving the waveform. Many students did not use the “Get System Directory.vi” function when creating the log file name but stored the path to the user folder in a path constant. Some students created the filename at initialization, and thus overwrote the same file each time.

The readability criteria include the size of the block diagram, which in this case, must not exceed the size of the screen, the alignment and spacing of the block diagram elements, and the clarity of the wiring. Large block diagrams and unorganized wires are at the top of the bad smells list in LabVIEW system models [67]. The block diagrams made by the students were of a reasonable size, but the alignment of the elements could be improved slightly and unnecessary wire bends avoided. The documentation and development of the stand-alone application had the most shortcomings, due mainly to time constraints and because the students prioritized a working application. This often resulted in missing short descriptions in the properties of the main VI and subVIs, and an incorrect name or storage location of the stand-alone application.

The results of this assessment project confirm that the students have acquired the necessary knowledge to create functional LabVIEW programs with the appropriate programming style. Some students had difficulties with the use of the hardware driver and lost too much time with that. Therefore, it is planned to add a separate assignment at the beginning of the exercises with the hardware that will be used in the assessment project. This will give the students more time to improve their documenting and testing.

4.3. Discussion

Both courses have been carried out according to the described procedure over the last few years. Our experience indicates that in the initial phase of learning a new programming language, it is more practical to use the face-to-face method. Using this approach, students follow the teacher’s instructions, which ensures a high degree of guidance. Students can work on real hardware and have the opportunity to ask questions on the fly, which enhances their understanding of the topic. When first interacting with the development environment, programming structures, programming syntax, functions, etc., there are often mistakes and questions that can be quickly resolved with a face-to-face approach. At this stage, creativity is not yet at the forefront; the key is to quickly correct errors so that the student does not become confused or frustrated by the obstacles and loses motivation to continue learning. However, this learning approach can be somewhat ineffective for students who already know some of the basics and may find the guided learning process rather boring. In addition, teaching and learning are limited to the time when staff are present in the laboratory, reducing the opportunities for in-depth experimentation.

In the flipped classroom method, students are introduced to new material at home through videos and other materials, allowing them more time for practical work in the laboratory. This allows them to use laboratory time for in-depth discussions and to strengthen their knowledge instead of working on basic information. This approach allows a more efficient use of laboratory time for experimentation and concrete problem solving. Despite its advantages, this method requires a high degree of self-discipline, as students have to process the material independently without direct supervision from the teacher, which can be challenging. Our experience shows that the flipped classroom method is more appropriate for teaching advanced LabVIEW programming. One of the most important reasons is the limited time available for students to work in the laboratory. However, a prerequisite for this approach is well-prepared video material, assignments, and quizzes, which the student must thoroughly study and complete before entering the laboratory.

In the introduction course, students are introduced to the development environment, basic building blocks, principles of operation, and modularity. In the end, the gained knowledge is assessed by a quiz. Successful completion of the quiz shows that the student has acquired the basic knowledge and understands the key principles of operation, but the quiz does not test whether the student is able to implement the algorithms using LabVIEW in practice.

In the advanced course, students upgrade their knowledge with more advanced functionalities, with the primary objective of developing high-quality code. In preparation for the laboratory work, students study the relevant topics independently, while in the laboratory, they discuss with the teacher the quality of the code in terms of aspects such as modularity, the readability of the code, the optimization of repetitive parts of the code, and the design of a user-friendly interface. The assessment involves students completing a large-scale project covering all the essential aspects of an industrial project. This brings up the following critical question: how to ensure a fair and thorough project evaluation? To address this, we have developed a detailed evaluation procedure. Students are provided with clear guidelines regarding the assessment project, including the expected graphical user interface and software functionality. The project is then evaluated using detailed evaluation criteria that ensure the transparency and fairness of the evaluation process.

Based on the results and our experience, we can confirm that the flipped classroom approach to teaching advanced LabVIEW programming techniques yields positive outcomes. All students met most of the criteria for delivering high-quality LabVIEW code, thus successfully completing the project. Given the limited time available for laboratory work, the complexity and quality of the developed evaluation projects are impressive. With the acquired knowledge and skills in LabVIEW programming, they are able to implement more challenging industrial projects.

5. Conclusions

This article presents two distinct pedagogical approaches to teaching LabVIEW programming at the university level. Since an extra course could not be added and because it was necessary to maintain the total length of the courses, the students are introduced to LabVIEW programming during laboratory work within the Electrical Measurements course, which is taught in the first year, and then learn more advanced programming techniques in their upper years.

The laboratory exercises in Electrical Measurements start with the hands-on Introduction to LabVIEW course. During the course, the students become familiar with graphical programming based on the dataflow programming model, with an emphasis on the modular design of LabVIEW programs. This is conducted using traditional face-to-face teaching blended with e-learning and an in-house developed data acquisition device called SimpleDAQ. The teacher first explains the topic and then the students complete a related practical exercise. The exercises complement each other and are designed as a small project, resulting in a temperature control application using a SimpleDAQ device which includes most of the topics covered in the course. Due to the large number of students in the first year, the assessment is based on a quiz covering the knowledge and understanding of the LabVIEW programming environment and the basics of LabVIEW programming taught in the course. In this way, the students acquire sufficient knowledge of LabVIEW programming in their first year, which they apply and extend in subsequent courses and projects.

The Standardization and Quality Assurance (SQA) course is taught in the second year. This course is compulsory for Automation and Robotics students and includes an advanced LabVIEW programming course. The Advanced LabVIEW course teaches students common programming techniques and styles to develop functional applications that are readable, scalable, and maintainable. The advanced course uses a flipped classroom model, where the students study video lectures independently in their home environment and then complete practical exercises in the laboratory. At the end of the course, the students complete a four-hour assessment project covering most of the topics taught in the advanced LabVIEW course. The results obtained from an analysis of the LabVIEW programs written by the students confirm that the students have acquired the knowledge necessary to create functional LabVIEW programs with the appropriate programming style.

Based on the results presented, it can be argued that the combination of classical face-to-face and flipped classroom teaching methods has a positive impact on the quality of students’ final projects. All students met most of the criteria for delivering high-quality LabVIEW code, thus successfully completing a relatively complex project within a predefined timeframe.

The face-to-face method proves especially beneficial during the initial phase of instruction. At this stage, students frequently encounter errors and have questions that can be promptly addressed through direct interaction. This immediate feedback helps to resolve issues quickly and supports a solid understanding of fundamental concepts.

Conversely, the flipped classroom approach is highly effective in the advanced phase of learning. In this phase, students engage with course material independently at home and can utilize laboratory time more effectively. This approach allows a more in-depth interaction with the equipment, more meaningful and quality collaboration with the teacher, and the opportunity to implement more large-scale and creative projects.

During further studies, some students extend their acquired knowledge in various projects and final theses, which usually involve the design of more complex algorithms and the use of various hardware. In their final projects, the students often solve real-world problems from industries that require the LabVIEW programming skills they have acquired in the presented courses.

Based on our experience in teaching LabVIEW programming, we recommend applying the described approaches to other technical courses, particularly when direct interaction time with students is limited.