Introduction to Programming using IoT

Comprehensive vocabulary flashcards covering fundamental electronics, Arduino programming, sensors, actuators, and cloud-connected IoT systems based on the DS1201 course lectures.

Circuit

A closed conducting path consisting of a power source, electrical components, and connections (such as copper wires) through which electric current can continuously flow.

Voltage

The electrical potential difference between two points in a circuit or across the terminals of a power source, measured in volts ($V$).

Electric Current

The flow of electric charge through a closed circuit, conventionally flowing from the positive (+$) terminal to the negative (-$$) terminal of the power source.

Light-Emitting Diode (LED) Polarity

A semiconductor light source with strict polarity: the longer leg is the positive terminal (anode) and the shorter leg is the negative terminal (cathode). Current enters through the anode and exits through the cathode.

Resistor

A non-polarized passive electrical component with color-coded bands that regulates or limits the amount of electric current flowing through a circuit, measured in ohms ($\Omega$).

Ohm's Law

A fundamental electrical law defining the direct mathematical relationship between voltage, current, and resistance: $V = I \times R$, where $V$ is voltage, $I$ is current, and $R$ is resistance.

Piezo Buzzer

A non-polarized electronic component composed of two discs of differing materials that converts electrical energy into sound by vibrating when voltage is applied.

Pushbutton

A mechanical switch with no polarity that connects two points of a circuit when pressed (closing the circuit) and disconnects them when released (opening the circuit).

Microcontroller

A compact computer on an integrated circuit (such as the Arduino UNO WiFi Rev2) designed to act as the digital brain of a circuit by executing programmed instructions sequentially.

Flowchart

A standardized visual diagram mapping out the sequential logic of an algorithm or program before coding, using ovals for start/end, rectangles for actions, and diamonds for conditions.

Digital Signal

An electrical signal that exists in only one of two discrete binary states: HIGH ($5\,V$ or $1$) and LOW ($0\,V$ or $0$).

pinMode()

A built-in setup function used to configure a specific digital pin to behave either as an INPUT (receiving data) or an OUTPUT (sending data).

digitalRead()

A function that reads the electrical voltage level on a specified digital pin and returns either HIGH or LOW.

digitalWrite()

A function that outputs a specified digital state, either HIGH ($5\,V$) or LOW ($0\,V$), to a designated digital output pin.

Pull-Down Resistor

A high-value resistor (typically $10\,k\Omega$) connecting an input pin to ground ($0\,V$) to hold the line at a definite LOW state when a switch is unpressed, preventing floating inputs.

Conditional Statement

A programming construct (if, else if, else) that evaluates a condition to boolean true or false and determines which subsequent code block the microcontroller executes.

Assignment Operator vs. Equality Operator

A single equals sign (=) is used strictly to assign a value to a variable, whereas a double equals sign (==) is a comparison operator used to evaluate whether two expressions are identical.

Logical Operators (&& and ||)

Logical operators used to combine multiple conditions: && (AND) requires all evaluated conditions to be true, whereas || (OR) requires at least one condition to be true.

random(min, max)

An Arduino function that generates pseudo-random numbers within a specified boundary, where the minimum value is inclusive and the maximum value is exclusive.

Serial Communication

A digital communication protocol where data is transmitted sequentially bit by bit between a microcontroller board and a computer over Tx (transmit) and Rx (receive) channels.

Baud Rate

The speed of serial data transmission expressed in bits per second (such as $9600\,\text{baud}$ or $115200\,\text{baud}$), which must be configured identically on both the board and the host receiver.

Serial.println() vs. Serial.print()

Serial.println() prints data to the Serial Monitor followed by a carriage return and newline character (moving to the next line), whereas Serial.print() prints data on the exact same line.

Hardware Serial Pins (Tx / Rx)

Pins 1 (Tx) and 0 (Rx) on the Arduino Uno, which are internally wired to the board's USB-to-serial transceiver and must remain disconnected during sketch upload to avoid signal interference.

Serial Buffer

A dedicated FIFO (First-In, First-Out) memory storage area that temporarily holds incoming serial data until the microcontroller processes it using Serial.read().

Serial.available()

A function that returns the total count of bytes or characters currently stored in the serial receive buffer ready to be read.

Serial.read()

A function that extracts and removes the first available character or byte of incoming data from the serial receive buffer.

char Data Type

A data type used to store single alphanumeric characters or symbols enclosed in single quotation marks (such as 'a'), represented internally by their ASCII numeric values.

Array

A collection of variables of the exact same data type grouped under a single name, allocated contiguously in memory, and accessed via an index starting at index $0$.

for Loop

A programmatic loop structure that repeatedly executes a block of code a specified number of times using an initialization variable, a termination condition, and an incremental/decremental step.

Global Variable vs. Local Variable

Global variables are declared outside functions, reside in memory continuously, and are accessible everywhere; local variables are declared within specific curly braces, exist only during execution of that block, and cannot be accessed outside it.

sizeof()

A compile-time C++ operator that returns the total number of bytes or array elements allocated to a specified variable or array.

Analog Signal

A continuous electrical signal capable of taking an infinite number of voltage values within a defined range (such as $0\,V$ to $5\,V$), reflecting real-world environmental phenomena.

analogRead()

A function that reads an incoming voltage from an analog pin (A0–A5) via a 10-bit analog-to-digital converter, mapping $0\,V$ to $0$ and $5\,V$ to $1023$.

Potentiometer

A three-terminal variable resistor whose adjustable knob or wiper divides voltage, allowing manual analog control over circuit signals.

Phototransistor

A light-sensitive polarized semiconductor component that regulates the current passing through it in proportion to the intensity of light falling on its surface.

Ultrasonic Sensor (US-016)

A sonar-based proximity sensor equipped with an ultrasonic emitter ('T') and receiver ('R') that measures distance based on the flight time of reflected high-frequency sound waves.

Serial Plotter

A built-in diagnostic utility in the Arduino IDE (Tools > Serial Plotter) that automatically renders real-time numerical serial values as continuous lines on an axis.

Pulse Width Modulation (PWM)

A method of producing an analog-like output voltage from digital pins marked with ~ by rapidly alternating the digital signal between HIGH and LOW.

Duty Cycle

The percentage of time a periodic digital signal spends in the active HIGH state over one complete cycle: $\text{Duty Cycle} = \frac{\text{Pulse Width}}{\text{Period}} \times 100\%$.

analogWrite()

A function that outputs an 8-bit PWM wave ($2^8 = 256$ steps, from $0$ to $255$) to an enabled pin, where $0$ represents $0\%$ duty cycle ($0\,V$) and $255$ represents $100\%$ duty cycle ($5\,V$).

map()

A built-in scaling function formatted as map(value, fromLow, fromHigh, toLow, toHigh) that linearly translates a numerical value from an original range into a target range.

tone() and noTone()

tone(pin, frequency) generates a square-wave sound signal of a specified frequency on any digital pin connected to a piezo buzzer, and noTone(pin) terminates that signal.

Standard Servo Motor

An actuator containing a DC motor, a gearbox, a potentiometer, and a control circuit that rotates its shaft precisely to any angle between $0^{\circ}$ and $180^{\circ}$.

Servo Gearbox

A mechanical gear assembly internal to a servo motor that reduces the high rotational speed of the DC motor to increase output torque and power.

Common Ground

The practice of tying the negative terminal of an external power source directly to the Arduino's GND pin to establish a shared $0\,V$ electrical reference baseline across the entire circuit.

Datasheet

A manufacturer document specifying electrical operating ratings, pin configurations, current consumption limits, mechanical dimensions, and tolerances of a component.

Watt's Law

The mathematical relationship determining electrical power consumption in watts, defined as: $\text{Power (Watts)} = \text{Voltage (Volts)} \times \text{Current (Amperes)}$.

Function

A named, modular block of code designed to perform a distinct task, which can be reused throughout a sketch to eliminate repetitive coding and ease debugging.

Parameter vs. Argument

A parameter is the placeholder variable declared in a function definition; an argument is the concrete value supplied to that parameter when invoking the function.

Return Value

The data handed back to the calling expression by a function upon completing its instructions, initiated using the return statement.

void Keyword

A function declaration keyword specifying that the function performs an action but returns no data value to the caller upon completion.

Class and Object

A class is an abstract blueprint defining structure and behavior (e.g., Servo), while an object is an instantiated, usable entity created from that class (e.g., Servo myServo;).

Method vs. Function

A function is a standalone tool (e.g., analogRead(A0)), whereas a method is a specialized function permanently bound to an object and invoked via an access dot operator (e.g., myServo.write(90)).

Application Programming Interface (API)

The standardized documentation and command interface detailing the methods, parameters, and behaviors provided by a pre-written library.

Serial.parseInt()

A stream-processing function that skips incoming non-digit characters in the serial buffer and parses the first encountered group of digits into an integer.

Internet of Things (IoT)

A global infrastructure of uniquely addressable, interconnected physical objects embedded with sensors and network electronics that collect and exchange data over the internet.

Arduino MKR WiFi 1010

A microcontroller board based on the SAMD21 architecture equipped with onboard Wi-Fi and Bluetooth connectivity, serving as the central brain of the Explore IoT Kit.

MKR IoT Carrier

An expansion shield designed for the Arduino MKR family featuring built-in environmental sensors, an IMU, an RGB display, relays, capacitive touch buttons, and an SD slot.

HTS221 Sensor

An integrated sensor on the MKR IoT Carrier that reads relative humidity ($\pm 3.5\%\,\text{rH}$ accuracy) and temperature over a range from $-40\,^{\circ}\text{C}$ to $+120\,^{\circ}\text{C}$.

Capacitive Touch Buttons

Five integrated touch-sensitive pads (labeled 00 to 04 / TOUCH0 to TOUCH4) on the MKR IoT Carrier that detect capacitance changes caused by finger contact.

Arduino Cloud Agent

A background software service installed on a local computer that enables browser-based Arduino tools (like Cloud Editor) to communicate serially with connected boards via USB.

Arduino Cloud Thing

A virtual object in the Arduino Cloud representing an IoT project, containing the configuration of associated hardware, cloud variables, network credentials, and auto-generated sketches.

Cloud Dashboard

A customizable visual web interface in the Arduino IoT Cloud composed of interactive widgets that allow users to display real-time sensor streams and trigger remote actuators.

Cloud Widget

A modular graphical user interface component (such as a Gauge, Slider, Messenger, Chart, or Switch) in an Arduino Cloud dashboard bound to a specific cloud variable.

CoolTerm

A third-party serial port terminal utility used to monitor and log raw incoming serial data from an Arduino board directly into local CSV or text files.

millis()

A built-in timekeeping function that returns the total elapsed time in milliseconds since the board began running the current program, useful for non-blocking timing and timestamps.

Serial Peripheral Interface (SPI)

A synchronous serial communication bus protocol used for high-speed, short-distance data exchange between microcontrollers and peripherals such as SD memory cards.

LPS22HB

A digital barometric pressure sensor on the MKR IoT Carrier that measures atmospheric pressure between $260$ and $1260\,\text{hPa}$ using an internal piezoresistive silicon membrane.

LUX

A photometric unit of illuminance equivalent to one lumen per square meter ($\text{lm}/\text{m}^2$), quantifying light intensity calibrated to the human eye's spectral sensitivity.

APDS-9960

An integrated multi-functional optical sensor on the MKR IoT Carrier used to detect ambient light intensity, RGB colors, proximity, and directional gestures.

Inertial Measurement Unit (IMU)

An integrated electronic sensor module (LSM6DS3) combining a 3-axis accelerometer and a 3-axis gyroscope to track an object's acceleration, velocity, and angular orientation.

Gyroscope

A sensor that measures angular rotational velocity along the orthogonal $x$, $y$, and $z$ axes to determine the physical orientation and tilt of a device.

Accelerometer

A sensor that measures dynamic acceleration, vibration, and static gravitational forces along the $x$, $y$, and $z$ axes.

Actuator

An electronic component (such as a motor, relay, screen, or speaker) designed to convert an electrical control signal into a physical output or action.

RGB LED (Carrier)

A multi-color lighting component containing red, green, and blue light elements whose brightness values are individually set from $0$ to $255$ in the order pixel index, green, red, blue.

Relay

An electrically operated switch that uses an electromagnet to mechanically open or close higher-power circuits, producing an audible 'tick-tack' clicking sound.

On Change Update Mode

An Arduino Cloud variable setting configured so that variable updates are pushed over the network only when the value changes, saving bandwidth.

ST77XX

The display driver controller chip family that drives the integrated $240 \times 240$ pixel color screen on the MKR IoT Carrier.

Switch Case Statement

A control-flow structure that evaluates an integer expression against multiple matching case values, utilizing break statements to exit and prevent fall-through.

Over-The-Air (OTA) Upload

A cloud feature that allows sketches to be flashed wirelessly to an internet-connected Arduino board without requiring a physical USB cable connection.