Unit 6: IoT with Thingspeak - Subjective Questions

ThingSpeak is a cloud-based IoT analytics platform used to collect, store, visualize, and analyze data received from connected devices.

Its major roles include:

• Data collection: It receives sensor readings from devices such as NodeMCU through HTTP or MQTT protocols.
• Channel-based storage: Data is organized into channels, with each channel supporting multiple fields for different sensor values.
• Data visualization: ThingSpeak displays information using charts, gauges, and other visual tools.
• Data analysis: MATLAB-based tools can be used to process and analyze the collected data.
• Remote monitoring: Users can observe sensor values from anywhere through an internet connection.
• Automation: ThingSpeak can trigger actions using alerts, MATLAB Analysis, or ThingHTTP services.

Thus, ThingSpeak acts as an intermediary between IoT devices, cloud storage, data analysis, and users.

The procedure for creating a ThingSpeak channel generally involves the following steps:

• Create an account: Register and sign in to the ThingSpeak platform.
• Create a channel: Select the option to create a new channel and provide a suitable name and description.
• Configure fields: Enable fields for the sensor values, such as temperature, humidity, light intensity, or pressure.
• Add metadata: Configure location, elevation, and other optional information when required.
• Save the channel: Save the configuration to generate the channel.
• Obtain API keys: Copy the Write API Key for sending data and the Read API Key for retrieving data.
• Configure visualization: Select suitable charts or widgets for displaying each field.
• Test communication: Send sample data from the NodeMCU and verify that it appears correctly in the channel.

The channel must be configured carefully because the field numbers and API keys must match the program running on the IoT device.

A NodeMCU sends sensor data to ThingSpeak through a Wi-Fi network and an internet connection. The typical process is:

• The NodeMCU connects to a configured wireless network using its SSID and password.
• Sensors connected to the NodeMCU are read using digital or analog input pins.
• The program converts the readings into suitable numerical values.
• The device creates an HTTP request or MQTT message containing the channel identifier, API key, and field values.
• ThingSpeak receives the request and stores the values in the specified channel.
• The server updates charts and makes the information available for later analysis.

For an HTTP request, the transmitted information conceptually contains a write key and field values, such as field1=temperature and field2=humidity. The program should also handle connection failures, invalid sensor readings, and the minimum update interval imposed by the ThingSpeak service.

The major programming steps are:

• Include libraries: Add the required Wi-Fi and HTTP or ThingSpeak client libraries.
• Declare credentials: Define the Wi-Fi SSID, password, ThingSpeak channel number, and write API key.
• Initialize hardware: Configure sensor pins and begin serial communication for debugging.
• Connect to Wi-Fi: Repeatedly attempt connection until the NodeMCU obtains network access.
• Read sensors: Acquire and validate the sensor measurements.
• Prepare the update: Assign the measurements to the appropriate ThingSpeak fields.
• Send the update: Use an HTTP request or the ThingSpeak library to upload the values.
• Check the response: Confirm whether the server accepted the update.
• Wait before the next update: Use a suitable delay or timer to comply with server limits.

A robust program should separate Wi-Fi connection, sensor reading, data transmission, and error handling into logical sections. It should also avoid exposing credentials in publicly shared source code.

The two API keys provide different access permissions:

• Write API Key:

  • Used by an IoT device to send or update data in a channel.
  • Must be included in upload requests.
  • Should be kept private because unauthorized users could insert false data.

• Read API Key:

  • Used by an application or user to retrieve private channel data.
  • Allows authorized reading without granting permission to modify the channel.
  • Is needed only when the channel is private; public channel data may be readable without it.

Separating read and write permissions improves security. A device should normally be given only the write key, while dashboards or analysis applications should receive only the read key when appropriate.

Blynk is an IoT application platform that allows users to monitor and control hardware through mobile or web interfaces.

Its main components are:

• Blynk application or web console: Provides dashboards containing widgets for displaying data and controlling devices.
• Blynk library: A software library installed in the microcontroller program to communicate with the Blynk cloud.
• Blynk cloud: Authenticates devices and transfers data between hardware and user interfaces.
• Device template: Defines the hardware type, communication method, data streams, and interface configuration.
• Auth token or device credentials: Identifies and authorizes a device.
• Virtual pins or datastreams: Carry values between the application and the microcontroller without being restricted to physical pins.
• Widgets: Buttons, switches, gauges, charts, sliders, and notifications provide interaction and visualization.

Blynk simplifies IoT development by combining device connectivity, cloud communication, and user-interface design.

The general procedure for creating a Blynk-based smart device is:

• Create a Blynk account and open the web or mobile console.
• Create a device template and select the microcontroller, such as NodeMCU or ESP8266.
• Select the communication method, such as Wi-Fi.
• Define datastreams for sensor values and actuator commands.
• Create a device from the template and obtain its device credentials.
• Install the Blynk library in the development environment.
• Program the NodeMCU with the Wi-Fi credentials and Blynk device credentials.
• Connect sensors and actuators to suitable GPIO pins.
• Build a dashboard using widgets such as value displays, switches, gauges, and charts.
• Upload the program, bring the device online, and test both monitoring and control operations.

The device program must update sensor datastreams regularly and respond to commands received through the configured datastreams.

ThingSpeak and Blynk are both IoT platforms, but they emphasize different use cases.

ThingSpeak is particularly suitable when long-term data analysis is important. Blynk is more suitable when users need a convenient interface for real-time monitoring and actuator control. Both platforms can also be used together in a larger IoT architecture.

Virtual pins and datastreams provide a flexible way to exchange information between a Blynk dashboard and a microcontroller.

• A datastream defines the type, range, and direction of a value transferred through Blynk.
• A virtual pin represents a software channel rather than a physical GPIO pin.
• Sensor values can be sent from the NodeMCU to the application through virtual pins.
• Commands from widgets, such as an ON/OFF button, can be received by the NodeMCU through virtual pins.
• A callback function in the device program processes values received from the application.
• A timer can periodically read sensors and update the corresponding datastreams.

For example, a temperature sensor may send its reading through V0, while a virtual switch on V1 may control a relay. This method separates the dashboard design from the physical wiring and makes the application easier to modify.

Edge computing is a computing approach in which data is processed close to the location where it is generated, such as on a sensor node, gateway, or local controller, instead of sending all data to a distant cloud server.

It is important in IoT because it:

• Reduces latency: Local decisions can be made quickly.
• Saves bandwidth: Only relevant or summarized data needs to be sent to the cloud.
• Improves reliability: The system can continue operating during temporary internet outages.
• Enhances privacy: Sensitive data can be filtered or processed locally.
• Reduces cloud cost: Fewer cloud requests and less storage may be required.
• Supports real-time control: Safety and automation decisions can be made immediately.

For example, an edge controller can turn off an industrial motor when excessive vibration is detected, without waiting for a cloud response.

In a cloud-based design, the sensor sends every temperature reading to a remote server. The server stores and analyzes the data and may send a command back to the device. This design provides centralized storage and powerful analysis but depends more heavily on network availability and introduces communication delay.

In an edge-based design, a local NodeMCU or gateway analyzes the temperature. It can immediately activate a fan when a threshold is exceeded and send only periodic summaries to the cloud.

A hybrid design is often best: urgent control is handled at the edge, while historical storage and advanced analysis are performed in the cloud.

An autonomous system is a system that can sense its environment, make decisions, and perform actions with limited or no continuous human intervention.

Important characteristics include:

• Sensing: Sensors collect information about the environment or system state.
• Perception: The system interprets sensor data.
• Decision-making: Rules, algorithms, or artificial intelligence determine an action.
• Actuation: Motors, valves, relays, or other actuators carry out the decision.
• Feedback: The system observes the result and adjusts its behavior.
• Adaptation: Some systems learn from data or respond to changing conditions.
• Safety and fault handling: The system detects abnormal conditions and moves to a safe state.

Applications include autonomous vehicles, robotic vacuum cleaners, smart irrigation, industrial process control, medical monitoring, and warehouse robots. IoT connectivity can provide remote supervision, data logging, and software updates.

IoT, robotics, and automation are related but distinct concepts.

• IoT connects sensors, devices, networks, and cloud services so that data can be exchanged and analyzed.
• Robotics focuses on machines that sense their surroundings and perform physical actions using mechanisms, controllers, and actuators.
• Automation refers to carrying out tasks with minimal human intervention using predefined rules or intelligent control.

Their relationship can be summarized as follows:

• IoT supplies connected sensing, communication, and remote monitoring.
• Robotics supplies physical movement and interaction with the environment.
• Automation supplies the logic that converts observations into actions.

For example, an agricultural robot may use soil sensors and GPS, communicate through an IoT network, and automatically apply fertilizer only where required. This combination improves efficiency, traceability, and remote supervision.

Energy-efficient IoT design aims to maximize operating life and reduce power consumption. Important principles include:

• Low-power hardware: Select microcontrollers, sensors, and communication modules with low current consumption.
• Sleep modes: Put the controller and radio into deep sleep when they are inactive.
• Duty cycling: Turn sensors and communication circuits on only when measurements are required.
• Efficient communication: Transmit compact packets and avoid unnecessary updates.
• Local processing: Filter or aggregate data before transmission.
• Adaptive sampling: Reduce the sampling rate when the monitored condition is stable.
• Efficient power supply: Use suitable regulators, batteries, and energy-harvesting sources.
• Event-driven operation: Wake the device when a threshold or external event occurs.
• Software optimization: Avoid busy waiting and use timers or interrupts.

A complete design must consider both active power and sleep power because a battery-operated device may spend most of its time in the sleep state.

Suppose an IoT device operates in several states. If state consumes current for time during a repeated operating cycle, the average current is:

If the battery has effective capacity in ampere-hours, the ideal battery life is approximately:

where is measured in hours. In practice, the usable life is lower because of regulator losses, battery aging, temperature, self-discharge, and the effect of high current pulses. A practical estimate may be written as:

where represents the overall efficiency factor.

Factors affecting battery life include:

• Sensor sampling frequency.
• Wi-Fi or radio transmission duration.
• Controller active and sleep currents.
• Battery capacity and discharge characteristics.
• Environmental temperature.
• Network retries and poor signal strength.
• Power consumed by actuators and indicators.

Reducing transmission frequency and increasing sleep time often produces significant savings.

IoT in agriculture uses connected sensors, controllers, communication networks, and analytics to improve farming decisions and resource use.

Applications include:

• Soil monitoring: Soil-moisture, temperature, and nutrient sensors support better crop management.
• Smart irrigation: Controllers supply water according to soil conditions and weather information.
• Weather monitoring: Local stations measure rainfall, humidity, temperature, and wind.
• Greenhouse automation: IoT systems regulate ventilation, lighting, humidity, and temperature.
• Livestock monitoring: Wearable devices can track location, movement, health, and feeding behavior.
• Crop surveillance: Cameras and sensors help detect pests, disease, or water stress.
• Equipment tracking: Connected machinery can report location, fuel use, and maintenance needs.

Benefits include reduced water and fertilizer consumption, improved yield, early detection of problems, lower labor requirements, and data-driven decision-making. Edge processing can allow irrigation decisions even when internet connectivity is unreliable.

A smart irrigation system can be designed with the following components:

• NodeMCU with Wi-Fi connectivity.
• Soil-moisture sensor.
• Temperature and humidity sensor.
• Relay module and water pump.
• ThingSpeak channel for data storage and visualization.
• Suitable power supply and protective enclosure.

Operation:

• The NodeMCU periodically reads soil moisture and environmental values.
• It compares soil moisture with a configured threshold.
• If the soil is too dry, it activates the relay and pump for a controlled period.
• When adequate moisture is reached, it switches the pump off.
• The readings and pump status are uploaded to separate ThingSpeak fields.
• Charts provide historical information about irrigation and environmental conditions.
• Alerts can be configured when moisture becomes critically low or the pump operates unusually long.

The design should include sensor calibration, hysteresis to prevent rapid relay switching, water-level protection, manual override, and low-power operation.

IoT in healthcare connects medical sensors, wearable devices, gateways, cloud platforms, and healthcare professionals.

Applications include:

• Remote patient monitoring: Devices measure heart rate, blood oxygen level, temperature, blood pressure, and glucose level.
• Wearable fitness and health tracking: Wearables record activity, sleep, and physiological information.
• Medication management: Smart dispensers provide reminders and record adherence.
• Hospital asset tracking: Connected systems locate wheelchairs, infusion pumps, and other equipment.
• Patient safety: Sensors can detect falls, wandering, or abnormal vital signs.
• Environmental monitoring: Hospital systems monitor room temperature, humidity, and air quality.
• Telemedicine support: Collected measurements can be shared with clinicians during remote consultations.

Benefits include earlier detection of health problems, reduced hospital visits, improved resource utilization, continuous observation, and more personalized care. Healthcare IoT requires strong privacy, authentication, encryption, reliability, and regulatory compliance.

Healthcare IoT devices handle sensitive personal and medical information, so security and privacy are essential.

Major challenges include:

• Unauthorized access: Weak passwords or poor authentication may expose patient data.
• Data interception: Unencrypted communication can reveal medical readings.
• Device tampering: Physical access may allow an attacker to modify a device or extract credentials.
• Insecure updates: Unverified firmware can introduce malicious code.
• Cloud and API risks: Poorly protected services may expose stored information.
• Availability threats: Denial-of-service attacks can interrupt monitoring or treatment support.
• Excessive data collection: Collecting unnecessary information increases privacy risk.

Important protections include encrypted communication, strong device identity, secure boot, signed firmware updates, access control, network segmentation, audit logging, regular vulnerability management, and data minimization. Safety-critical devices should also have local fail-safe behavior when the network or cloud service is unavailable.

A Blynk-based home automation system can use a NodeMCU, relay module, sensors, and the Blynk application.

• The NodeMCU connects to the home Wi-Fi network and Blynk Cloud.
• Relays are connected to GPIO pins through suitable driver circuits to control lamps, fans, or other appliances.
• Blynk switch widgets send ON/OFF commands through datastreams.
• The NodeMCU receives the commands and changes the relay states.
• Sensors can measure room temperature, light level, motion, or energy consumption.
• Sensor readings are sent to Blynk widgets such as gauges, labels, and charts.
• Automation rules can turn appliances on or off based on time, motion, or environmental thresholds.
• Notifications can inform the user about abnormal conditions or device status.

The design must electrically isolate the low-voltage controller from mains circuits, use properly rated relays, provide enclosure and protection, and include a manual fallback where appropriate.