SMRTTECH 3CC3 · Cloud Computing and Internet of Things

Lab 8: Soil Moisture Monitoring

Native LabVIEW calibration and alarm logic with MQTT telemetry, shared attributes, and ThingsBoard Cloud dashboards.

Pre-lab: 30-45 min Lab time: 3 hours Post-lab: 45-60 min Software: LabVIEW 2026 Q1, Lab8_init.vi, LINX, NI-VISA, ThingsBoard Cloud, MQTT Hardware: Arduino Mega, capacitive soil moisture sensor, cup of water

Central question: How does soil moisture become calibrated telemetry, a cloud-configured threshold, and a reliable local alarm?

Moisture monitoring and threshold chain

MoistureSoil or water changes dielectric condition.

Sensor voltageCapacitive sensor produces SIG voltage.

Arduino A0LabVIEW reads analog channel 0.

CalibrationV_dry and V_wet define range.

PercentNative LabVIEW arithmetic clamps 0 to 100.

MQTT telemetrySend JSON to ThingsBoard about once per second.

DashboardValue card, gauge, chart, and alarm indicator.

Local alarmLabVIEW reports low_moisture_alarm.

Threshold controlUser selects a setpoint.

Shared attributemoisture_threshold persists in ThingsBoard.

MQTT subscribeLabVIEW receives live changes.

Startup requestLabVIEW retrieves the current value after reconnect.

JSON parseValidate the numeric threshold.

Native comparemoisture_percent < moisture_threshold.

Local alarmOperates even during internet loss.

Telemetry feedbackReport low_moisture_alarm to ThingsBoard.

Prepare

Scenario and setup

You are building an IoT plant-monitoring node. Arduino Mega sends sensor voltage to LabVIEW through LINX. LabVIEW performs calibration and the primary low-moisture decision locally, then exchanges telemetry and a persistent threshold with ThingsBoard Cloud over MQTT.

Water-near-electronics caution: fill the cup only one-third with water. Keep hands dry. Do not spill water on Arduino, breadboard, laptop, or the top electronics of the sensor.

Credential caution: a ThingsBoard device access token is a password-equivalent credential. Never include it in this manual, a report screenshot, completion JSON, public GitHub repository, or shared class document.

Required software environment

Computer and LabVIEW

Windows 10 or Windows 11.
LabVIEW 2026 Q1; use 64-bit unless the installed MQTT library specifically requires another edition.
NI-VISA 2026 Q1.

Hardware interface

Arduino Mega 2560.
LabVIEW Hobbyist Toolkit / LINX 2026 Q1.
The course MQTT library and its required dependencies.

Materials Checklist

Confirm the required materials

Gather the following software, hardware, accounts, and course resources before beginning the lab.

LabVIEW and NI-VISA are installed. LabVIEW Hobbyist Toolkit / LINX and Arduino firmware for LINX are available. Lab8_init.vi and the required MQTT library are downloaded. ThingsBoard Cloud registration and student-email verification are available. Arduino Mega and a USB data cable are available. Breadboard and jumper wires are available. Capacitive soil moisture sensor is available. Cup and water are available for the wet calibration measurement.

Predict

Arrange the moisture data chain

Number the events from physical moisture to cloud analytics.

Capacitive sensor produces voltage Arduino A0 is read through LabVIEW LINX V_dry and V_wet calibration maps voltage to percent Native LabVIEW arithmetic computes moisture_percent and clamps it MQTT publishes a labelled JSON telemetry object ThingsBoard stores raw_voltage, moisture_percent, and low_moisture_alarm telemetry Dashboard cards, gauge, chart, and alarm indicator display the readings

Choose an order for every event.

Calibration and topic practice

Prompt	Your answer	Expected check
Publish topic for telemetry
Subscribe topic for live shared-attribute changes
If moisture_percent is 18 and threshold is 25, should the LabVIEW Low Moisture LED indicator be on?

Think it through

Does Arduino measure moisture directly?
Why are V_dry and V_wet specific to this sensor and setup?
Why clamp moisture_percent between 0 and 100?

Build

Create and Configure Your ThingsBoard Cloud Account

Open ThingsBoard Cloud
Open Entities → Devices, select Add Device, and name the device Lab8-Soil-Moisture-StudentName.
Leave the device profile as the default, then save.
Open the device details or connectivity information and copy its access token to a private local location.

One physical project normally equals one ThingsBoard device. Do not create a separate device for every sensor or actuator. Never paste the real token into this page. Use YOUR_DEVICE_ACCESS_TOKEN in examples and redact credentials from evidence.

ThingsBoard device name

The device token is stored in a private local location, ready for the next MQTT stage, and is absent from screenshots, reports, HTML, repositories, and completion exports. Local evidence reference: device page with the access token hidden (image or PDF)No local evidence file selected.Accepted: image file or PDF. This chooser records only the filename; it does not upload or submit the artifact.

ThingsBoard data model for this lab

Telemetry: measured or calculated state

LabVIEW publishes raw_voltage, moisture_percent, and low_moisture_alarm to v1/devices/me/telemetry.

Shared attribute: persistent configuration

The dashboard writes moisture_threshold. LabVIEW receives it on v1/devices/me/attributes

Keep the meanings separate: moisture_threshold is the cloud-configured setpoint; low_moisture_alarm is the actual alarm result calculated locally in LabVIEW.

Build

Configure and test LabVIEW MQTT with ThingsBoard

Download Lab8.zip from Avenue to Learn, extract it, and open Lab8_init.vi. Configure the existing MQTT tab without changing the portal's LabVIEW/LINX architecture.

Initial classroom configuration

Broker: mqtt.thingsboard.cloud; port: 1883
Username: the device access token; password: blank
Client ID: SMRTTECH3CC3-STUDENTNAME-LAB8
QoS: At least once
Publish: v1/devices/me/telemetry (no leading slash)
Subscribe: v1/devices/me/attributes

Transport security: port 1883 is unencrypted and is only for the controlled laboratory setup or initial connectivity testing. Use port 8883 only when the MQTT library explicitly supports TLS and certificate verification; entering 8883 alone does not enable TLS. Every simultaneously connected client must use a unique client ID.

If the MQTT connection or first publish fails

Confirm mqtt.thingsboard.cloud, the intended port, a unique client ID, the device token as Username, and a blank password.
Use the exact topic v1/devices/me/telemetry with no leading slash and validate the labelled JSON payload.
Confirm the token belongs to the same ThingsBoard device whose Latest Telemetry tab you are viewing; check whether the network blocks MQTT.

Connection and first-test sequence: Run the VI, select Connect, and wait for the connection-success indication before publishing. Send one labelled JSON object such as {"raw_voltage":2.81,"moisture_percent":34.6,"low_moisture_alarm":true} to v1/devices/me/telemetry; do not publish an unlabelled number. Open Entities → Devices → your Lab 8 device → Latest Telemetry and confirm that all three keys appear. Subscribe to v1/devices/me/attributes for live threshold changes and configure the response listener for requested attributes. After the VI is running, open Attributes → Shared Attributes, add moisture_threshold as a numeric value, change it once, and confirm the updated value is received by LabVIEW. Use Stop, not Abort, so MQTT, LINX/VISA, queues, events, and other references close cleanly.

Send a labelled JSON test

{"raw_voltage":2.81,"moisture_percent":34.6,"low_moisture_alarm":true}

Build the payload in LabVIEW with Concatenate Strings: place the key names, quotation marks, braces, commas, and formatted values in the required order to create one labelled JSON string. Do not publish an unlabelled number such as 42. Connect, publish once, subscribe, and confirm the JSON keys appear in the device's Latest Telemetry tab.

MQTT connection, JSON telemetry publish, and both subscriptions were tested successfully. Local evidence reference: Latest Telemetry with no credential visible (image or PDF)No local evidence file selected.Accepted: image file or PDF. This chooser records only the filename; it does not upload or submit the artifact.

Build

Create the capacitive soil moisture sensor circuit

Review the capacitive sensor, then build the circuit. Connect sensor GND to Arduino GND, VCC to Arduino 5 V, and SIG to Arduino A0.

Circuit diagram showing a capacitive soil-moisture sensor connected to Arduino Mega A0, 5 V, and GND. — Connect the moisture-sensor SIG pin to Arduino analog channel A0.

Soil-moisture sensor showing the safe insertion-depth region. — Do not submerge the top circuitry; insert only the recommended sensing region.

Sensor GND is connected to Arduino GND. Sensor VCC is connected to Arduino 5 V. Sensor SIG is connected to Arduino A0. Cup is one-third full and the top two-thirds are dry.

If the sensor reading is missing or fixed: stop the VI, disconnect Arduino USB, dry your hands, and move water away from the electronics. Verify VCC, GND, SIG to A0, sensor depth, USB, serial port, LINX firmware, and NI-VISA before restoring power.

Measure

Flash LINX and measure V_dry and V_wet

Flash LINX firmware using Tools - MakerHub - LINX - LINX Firmware Wizard. Add LINX Open, LINX Close, and LINX Analog Read in the Control and Data Acquisition loop. Configure the serial port and set analog channel to 0.

LabVIEW block diagram with LINX Open, LINX Analog Read, and LINX Close. — First read the sensor voltage without pressing Connect in the MQTT tab.

Calibration steps

Run LabVIEW without pressing Connect in the MQTT tab.
Record average sensor voltage in air as V_dry for 0% moisture.
Slowly dip the sensor until it touches the bottom of the cup.
Record that voltage as V_wet for 100% moisture.
Stop the VI before editing the block diagram.

Calibration reading	Voltage	Meaning
V_dry		0% moisture, sensor in air
V_wet		100% moisture, sensor dipped safely in water

If V_dry and V_wet are invalid or nearly identical

Use a consistent sensor depth, keep the top circuitry dry, and allow each reading to settle before averaging.
Confirm the values are measured, different, assigned to the correct dry/wet endpoints, and within the Arduino input range.
Recheck A0 wiring and LINX Analog Read before changing the calibration formula.

Local evidence reference: HMI front panel (image or PDF)No local evidence file selected.Accepted: image file or PDF. This chooser records only the filename; it does not upload or submit the artifact.

Measure

Convert voltage to percent moisture

Add a numeric moisture_threshold indicator, a LabVIEW front-panel Low Moisture round LED indicator, a moisture_percent numeric indicator, and a moisture_percent waveform chart. Build the calibration and alarm with native LabVIEW arithmetic, comparison functions, Boolean logic, and Case Structures as needed.

LabVIEW In Range and Coerce function with lower and upper limits, coerced output, and In Range Boolean output. — Use **In Range and Coerce** to keep the calculated moisture percentage within 0–100. Wire the scaled value to `x`, set the lower limit to 0 and upper limit to 100, use `coerced(x)` as `moisture_percent`, and use **In Range?** when you need to confirm whether the original value was already inside the limits.

scaled_percent = (V_wet - V_dry) / (raw_voltage - V_dry) * 100
moisture_percent = clamp(scaled_percent, 0, 100)
low_moisture_alarm = moisture_percent < moisture_threshold

Subtract V_dry from raw_voltage, divide by V_wet - V_dry, and multiply by 100.
Use minimum/maximum or In Range and Coerce functions to clamp the result from 0 to 100.
Use the Less? comparison to calculate low_moisture_alarm.
Keep a documented safe local threshold until a valid cloud value arrives.

Practice value	Input	Live check
Voltage to convert		Enter V_dry, V_wet, voltage, and threshold.
Threshold percent
Expected result	moisture_percent is clamped to 0-100 and low_moisture_alarm is true when percent is below threshold.

Measure

Publish JSON telemetry to ThingsBoard

In the Communication Loop, use LabVIEW Concatenate Strings to assemble the three current values into one labelled JSON object, then publish it to v1/devices/me/telemetry

{"raw_voltage":2.81,"moisture_percent":34.6,"low_moisture_alarm":true}

Local evidence reference: streaming Latest Telemetry (image or PDF)No local evidence file selected.Accepted: image file or PDF. This chooser records only the filename; it does not upload or submit the artifact.

Measure

Receive and synchronize moisture_threshold

Use moisture_threshold as a ThingsBoard shared attribute. Subscribe to v1/devices/me/attributes for event-driven live changes such as:

{"moisture_threshold":30}

Startup and reconnection synchronization

Subscribe to v1/devices/me/attributes.
The response may be {"moisture_threshold":30}. In LabVIEW, wire the received JSON string into Unflatten From JSON and provide a typed cluster constant containing a numeric moisture_threshold field. Connect the brown cluster output to Unbundle by Name, select moisture_threshold, and wire the resulting numeric value into the local setpoint logic. Until a valid response arrives, retain a documented safe default. On malformed JSON, show a readable error and preserve the last valid threshold instead of stopping the complete VI.

LabVIEW Unflatten From JSON function converting a JSON string into a typed cluster and numeric moisture_percent output. — Use this pattern for the Lab 8 threshold response: wire the JSON string into **Unflatten From JSON**, define the expected numeric field in a typed cluster, then connect the brown cluster wire to **Unbundle by Name**. Select `moisture_threshold` and use the numeric output in the comparison and threshold indicator.

What proves LabVIEW received a live change response from ThingsBoard? How does the VI use Unflatten From JSON and Unbundle by Name to validate received JSON and preserve a safe or last-valid threshold?

Local evidence reference: JSON parsing block diagram logic (image or PDF)No local evidence file selected.Accepted: image file or PDF. This chooser records only the filename; it does not upload or submit the artifact.

Explain

Build the Lab 8 Soil Moisture Dashboard

Open Dashboards, create a dashboard named Lab 8 Soil Moisture Dashboard, and open edit mode.
Create or select an entity alias that points to your Lab8-Soil-Moisture-StudentName device.
Add a value card for raw_voltage.
Add a 0–100 gauge and a time-series chart for moisture_percent.
Add an indicator for the Boolean telemetry key low_moisture_alarm.
Add a numeric threshold control that reads and writes the shared attribute moisture_threshold.
Optionally add an alarm-history, event-history, device-activity, or last-update widget.

Threshold control action: initial state must read shared attribute moisture_threshold; changes must set that shared attribute to a numeric value. Do not write telemetry, set a server-side attribute, or execute RPC. After changing the control, first confirm the value changes under the device's Shared Attributes tab, then troubleshoot LabVIEW if needed.

If a widget has no value or the threshold control has no effect

Confirm the entity alias points to the Lab 8 device and each widget uses the exact telemetry or shared-attribute key.
Confirm the threshold control sets numeric shared attribute moisture_threshold, not telemetry, RPC, or a server attribute.
Verify the value changes in the Shared Attributes tab before inspecting the LabVIEW subscription and JSON validation path.

raw_voltage value card and moisture_percent gauge display measured telemetry. Threshold control updates the shared moisture_threshold attribute. Time-series chart shows historical moisture_percent values. Moving the sensor updates telemetry and changing the threshold changes the local alarm when appropriate. low_moisture_alarm indicator is visibly distinct from measured moisture and configured threshold.

Local evidence reference: completed dashboard (image or PDF)No local evidence file selected.Accepted: image file or PDF. This chooser records only the filename; it does not upload or submit the artifact.

Revise

Validate the local alarm and internet-loss behaviour

The primary decision remains in LabVIEW:

low_moisture_alarm = moisture_percent < moisture_threshold

Normal operation

Set a known threshold.
Move the sensor so moisture crosses the threshold.
Confirm the local LabVIEW front-panel LED indicator changes immediately.
Confirm the reported low_moisture_alarm follows.

Cloud-loss test

Record the active threshold.
Disconnect MQTT or internet access.
Vary the sensor reading.
Confirm acquisition, calibration, comparison, and the local LabVIEW indicator continue.

Reconnect test

Restore connectivity.
Reconnect and resubscribe.
Request moisture_threshold.
Confirm telemetry resumes without unsafe output changes.

Cloud communication is not deterministic. Never use ThingsBoard as the inner loop of a fast controller. Stale, delayed, duplicate, or repeated commands must not create unsafe behaviour. A ThingsBoard alarm/history widget may observe low_moisture_alarm, but a cloud rule chain must not replace the local decision.

Record the normal, cloud-loss, and reconnect test results Local evidence reference: local alarm and internet-loss test (image or PDF)No local evidence file selected.Accepted: image file or PDF. This chooser records only the filename; it does not upload or submit the artifact.

Reflect

Learning Outcomes Achieved

Measure dry and wet reference voltages and implement a bounded native-LabVIEW moisture calibration.
Calculate a local low-moisture decision from a validated cloud-configured threshold.
Publish labelled telemetry and receive, validate, and resynchronize a persistent ThingsBoard shared attribute through MQTT.
Build a dashboard that distinguishes measured moisture, configured threshold, and the locally calculated alarm.
Verify that sensing and alarm logic remain safe during cloud loss, reconnection, and final hardware cleanup.

Deliverables and cleanup

Submit

Sensor circuit evidence and measured V_dry/V_wet.
Native LabVIEW calibration and local-alarm explanation.
HMI screenshot with raw_voltage, moisture_percent, moisture_threshold, front-panel Low Moisture LED indicator, and chart.
ThingsBoard Latest Telemetry evidence for all three telemetry keys.
Shared moisture_threshold evidence and startup synchronization test.
Completed dashboard with measured moisture, configured threshold, and locally calculated alarm visibly distinguished.
Internet-loss and reconnect results.
System block diagram, sensor comparison, application, suggestions, and cleanup confirmation.

Final cleanup warning

Stop the VI with its Stop control, not Abort.
Disconnect MQTT and close MQTT, LINX/NI-VISA, queue, event, and other references.
Keep the most recently valid threshold or documented safe default active during disconnect.
Turn off power, disconnect Arduino USB, remove the sensor, and let it dry.
Remove real credentials from local examples and clear saved front-panel token defaults before distributing a VI.

Final Lab 8 LabVIEW VI fileNo .vi file selected.

Submission questions

1. Draw a system block diagram showing data transfer between the web HMI, sensors, and actuators.No drawing file selected.Upload a clear image or PDF of your hand-drawn or digital system diagram. 2. Compare capacitive and resistive soil moisture sensors. Summarize operation and advantages of the capacitive sensor. 3. Explain the native LabVIEW calibration and alarm logic, and why measuring V_dry and V_wet is important. 4. Provide one real-life soil moisture sensor application and explain the benefits of making it IoT. 5. Include typos or suggestions for improving this lab manual.

Glossary

Capacitive soil moisture sensor

Sensor that responds to changes in dielectric properties around the probe rather than relying on exposed resistive electrodes.

Resistive soil moisture sensor

Sensor that estimates moisture from electrical resistance through soil, often more prone to corrosion.

V_dry

Voltage measured with the sensor in air, used as the 0% moisture calibration point.

V_wet

Voltage measured with the sensor safely dipped in water, used as the 100% moisture calibration point.

Calibration

Mapping raw sensor voltage to a meaningful percent range for this sensor and setup.

moisture_percent

Telemetry key for the locally calibrated and clamped moisture value from 0 to 100.

moisture_threshold

ThingsBoard shared attribute containing the persistent cloud-configured setpoint.

low_moisture_alarm

Boolean telemetry key calculated locally from moisture_percent < moisture_threshold.

Arduino A0

Analog input channel used to read the sensor SIG voltage.

LINX

LabVIEW toolkit used to communicate with Arduino.

Native LabVIEW logic

Arithmetic, clamp, comparison, Boolean, and Case Structure functions that keep calibration and the alarm local.

JSON validation

Parsing and validating a received shared-attribute value before replacing the last valid threshold.

Clamp

Limit a calculated value so it stays within an allowed range.

MQTT

Publish/subscribe protocol used to exchange JSON telemetry and shared attributes with ThingsBoard.

Telemetry

Measurement or actual-state data published by LabVIEW, including raw_voltage, moisture_percent, and low_moisture_alarm.

Shared attribute

Persistent cloud-to-device configuration; this lab uses moisture_threshold.

Entity alias

Dashboard data-source mapping that points widgets to the student's Lab 8 device.

Gauge and value card

Dashboard widgets for current moisture_percent and raw_voltage values.

Time-series chart

Dashboard widget used to show historical moisture_percent telemetry.

Alarm indicator

Dashboard display of the low_moisture_alarm result produced locally by LabVIEW.

Aggregation

Summary calculation such as minimum, maximum, or average over a time span.

IoT plant-monitoring node

Local sensor system connected to a cloud dashboard and alert workflow.