Mechatronics I: Exam 2 Study Guide

The correct answer is True. Digital systems operate on binary logic, representing information with distinct high and low voltage levels.

The correct answer is microcontroller. Microcontrollers are designed for specific control tasks in embedded systems.

The correct answer is b) To execute code continuously after initialization. The `loop()` function runs repeatedly, making it suitable for continuous sensing, processing, and actuating tasks.

The correct answer is Analog-to-Digital Conversion (ADC).

The correct answer is b) The number of discrete digital values it can produce. Higher resolution means more distinct digital levels to represent the analog input.

The correct answer is at least $2 \times F_{max}$ (twice the maximum frequency). This minimum rate is known as the Nyquist rate.

The correct answer is c) Duty cycle of the digital signal. By changing the proportion of time the signal is HIGH versus LOW, the average voltage can be controlled.

The correct answer is c) `pinMode()`. This function configures the direction of a specified pin.

The correct answer is True. `if` statements are fundamental for implementing conditional logic.

The correct answer is c) `for` loop. `for` loops are designed for definite iteration where the number of repetitions is predetermined.

The correct answer is 1101₂. (8 + 4 + 0 + 1 = 13)

The `Serial.begin()` function initializes serial communication between the Arduino board and a computer (or other serial device) at a specified baud rate. This allows the Arduino to send and receive data via the USB port for debugging or communication purposes.

Mapping (or scaling) in Arduino refers to converting a value from one range of numbers to another range. For analog sensor readings, this is often used to transform the raw ADC values (e.g., 0-1023) into a more meaningful physical unit or a different output range (e.g., 0-255 for LED brightness, or actual temperature in Celsius). The `map()` function in Arduino is commonly used for this purpose.

A microcontroller is designed for specific control tasks in embedded systems, typically with limited resources (CPU, memory) and optimized for real-time interaction with hardware. A general-purpose computer is designed for a wide range of tasks, with more powerful processors, larger memory, and extensive operating systems, focusing on flexibility and user interaction rather than direct hardware control.

The correct answer is False. A DAC performs the opposite function: it converts a discrete digital signal into a continuous analog signal.

The baud rate defines the speed at which data is transmitted serially, measured in bits per second (bps). It is crucial that both the transmitting and receiving devices are configured to the same baud rate for successful and intelligible communication.

A "floating" digital input pin is one that is not connected to a defined voltage (HIGH or LOW). Such a pin is highly susceptible to electromagnetic interference (EMI) or static electricity, causing it to randomly switch between HIGH and LOW states. This unpredictable behavior can lead to erroneous readings and unintended actions in a microcontroller program. Pull-up or pull-down resistors are used to prevent floating states.

The `delay()` function pauses the program for a specified number of milliseconds. It is used to introduce timed delays in the execution flow, which can be useful for blinking LEDs, waiting for sensor stabilization, or timing sequences of actions. However, it blocks other code from running during the delay.

`digitalWrite()` is used to set a digital pin to either a HIGH (5V/3.3V) or LOW (0V) state. It's for binary outputs.
`analogWrite()` (for PWM pins) is used to generate a Pulse Width Modulation signal, effectively producing an "analog-like" output by varying the duty cycle of a square wave. It takes a value from 0-255 to control the average voltage.

Overflow occurs when a calculation or operation produces a result that is too large to be represented by the available number of bits or data type. For example, if an 8-bit unsigned integer can hold values from 0 to 255, adding 1 to 255 would cause an overflow, typically resulting in the value wrapping around to 0.

Group the binary number into 4-bit nibbles: 1111 0000.
1111₂ = F₁₆
0000₂ = 0₁₆
So, the correct answer is F0₁₆.

The `const` keyword declares a variable as "constant," meaning its value cannot be changed after it has been initialized. This is useful for defining pin numbers or fixed parameters that should not be accidentally modified during program execution, improving code robustness and readability.

A `switch-case` statement is used to control the flow of execution based on the value of a single variable or expression. It allows for multiple execution paths. It is often preferred over a long series of `if-else if` statements when checking a single variable against many distinct constant values, as it can make the code more readable, organized, and sometimes more efficient.

A logic gate is an elementary building block of digital circuits that performs a basic logical function (AND, OR, NOT, etc.) on one or more binary inputs and produces a single binary output.
Example: An AND gate produces a HIGH output only if all its inputs are HIGH; otherwise, its output is LOW.

The `millis()` function returns the number of milliseconds that have passed since the Arduino board began running the current program. It is non-blocking, meaning it does not pause the program execution. This differs from `delay()` which halts all program execution for a specified duration, making `millis()` more suitable for multitasking and responsive applications.

A pull-up resistor connects an input pin to the positive voltage supply (e.g., 5V), ensuring the pin reads HIGH when left unconnected or when a switch is open.
A pull-down resistor connects an input pin to ground (0V), ensuring the pin reads LOW when left unconnected or when a switch is open.
Both are used to prevent input pins from "floating" and picking up random electrical noise, ensuring a defined logic state.

Aliasing is a distortion that occurs when an analog signal is sampled at a rate lower than twice its highest frequency component (the Nyquist rate). This causes higher frequencies in the original signal to be misrepresented as lower, incorrect frequencies in the digitized signal, making it impossible to accurately reconstruct the original waveform.

A `while` loop checks its condition *before* executing the loop body. If the condition is false initially, the loop body will never execute.
A `do-while` loop executes its loop body *at least once* before checking the condition. The condition is checked after each iteration, and the loop continues as long as the condition is true.

For an N-bit unsigned integer, the maximum value is $2^N - 1$.
For 8 bits: $2^8 - 1 = 256 - 1 = 255$.
The correct answer is 255.

Digital noise refers to unwanted, random fluctuations in voltage that can cause a digital input pin to rapidly switch between HIGH and LOW states, even when the intended signal is stable. This can lead to erroneous readings (e.g., multiple button presses from a single physical press). It can be mitigated using hardware solutions (e.g., pull-up/pull-down resistors, capacitors for debouncing) or software solutions (e.g., debouncing algorithms in code that ignore rapid changes within a short time window).

A function (or subroutine/method) is a block of organized, reusable code that performs a specific task. Its purpose is to break down complex problems into smaller, manageable parts, promote code reusability, improve readability, and simplify debugging.

An `int` (integer) data type stores whole numbers (e.g., 1, 100, -5). It uses 2 bytes of memory on most Arduinos and has a limited range.
A `float` (floating-point) data type stores numbers with decimal points (e.g., 3.14, -0.5, 10.0). It uses 4 bytes of memory and can represent a much wider range of values, but calculations with floats can be slower and less precise than with integers.

A 10-bit ADC produces $2^{10} = 1024$ discrete values. These values typically range from 0 to 1023.

The primary benefit is improved code readability and easier modification. By using a meaningful name (e.g., `const int ledPin = 13;`), the code becomes self-documenting. If the pin assignment needs to change, you only need to modify the `const` declaration once, rather than searching and replacing every instance of the raw number throughout the code, reducing errors.

A simple LED is typically connected with its anode (longer leg) to the Arduino digital output pin and its cathode (shorter leg) to ground, but with a current-limiting resistor placed in series with the LED. The resistor is crucial to limit the current flowing through the LED, preventing it from burning out due to excessive current from the Arduino pin.

The `if-else if-else` structure allows a program to execute different blocks of code based on a series of mutually exclusive conditions. The program evaluates conditions sequentially; the first condition that evaluates to true has its corresponding code block executed, and then the rest of the structure is skipped. If none of the `if` or `else if` conditions are true, the `else` block (if present) is executed.

The sampling rate (or sampling frequency) in ADC refers to how many times per second an analog signal is measured and converted into a digital value. It is measured in Hertz (Hz) or samples per second. A higher sampling rate captures more data points from the analog signal, allowing for a more accurate digital representation, especially for rapidly changing signals.

The `setup()` function in an Arduino sketch is executed only once when the Arduino board starts up or is reset. Its primary role is to initialize variables, set pin modes (INPUT/OUTPUT), start serial communication, and perform any other one-time configurations required for the program to run.

A `for` loop typically has its initialization, condition check, and iteration step defined at the beginning of the loop statement, making it ideal for iterating a fixed number of times or through a known sequence. A `while` loop only has a condition check at the beginning; its initialization and iteration steps must be handled explicitly within the loop body. `while` loops are better suited for indefinite iteration, where the number of repetitions is not known beforehand and depends on a condition becoming false.

Comments are non-executable lines of text within code that are ignored by the compiler. Their purpose is to explain the code, its logic, and its functionality to human readers (programmers). Good comments improve code readability, maintainability, and collaboration, making it easier for others (and your future self) to understand and modify the program.

Number of Steps = $2^{10} = 1024$

Resolution = Vref / Number of Steps
Resolution = 5.0 V / 1024
Resolution ≈ 0.0048828 V/step or 4.88 mV/step

Therefore, the voltage resolution is approximately 0.00488 V/step.

First, find the analog voltage corresponding to the digital reading:

ADC Resolution = 5.0 V / 1024 ≈ 0.0048828 V/step
Analog Voltage = Digital Reading * ADC Resolution
Analog Voltage = 512 * 0.0048828 V ≈ 2.5 V

Next, use the sensor's transfer function to find the temperature. The sensor range is 3.0 V - 0.5 V = 2.5 V for 100°C.
Sensor sensitivity = 2.5 V / 100°C = 0.025 V/°C.
The voltage measured is 2.5 V, which is 2.5 V - 0.5 V = 2.0 V above the 0°C reading.

Temperature = (Analog Voltage - Vmin_sensor) / Sensor Sensitivity
Temperature = (2.5 V - 0.5 V) / 0.025 V/°C
Temperature = 2.0 V / 0.025 V/°C = 80 °C

Therefore, the temperature is 80 °C.

Average Voltage = Supply Voltage * Duty Cycle
Average Voltage = 3.3 V * 0.60
Average Voltage = 1.98 V

Therefore, the approximate average DC equivalent voltage output is 1.98 V.

Minimum Sampling Rate = 2 * Fmax
Minimum Sampling Rate = 2 * 30 Hz = 60 Hz

Therefore, the theoretical minimum sampling rate is 60 Hz.

Number of Unique Values = 2N
Number of Unique Values = 212 = 4096

Therefore, 4096 unique, discrete values can be represented.

Total range = 100°C - 0°C = 100°C
Number of steps = Total range / Resolution = 100°C / 0.5°C/step = 200 steps
To find the minimum number of bits (N), we need $2^N \ge \text{Number of steps}$.

2N ≥ 200

We know:
$2^7 = 128$
$2^8 = 256$
So, N must be at least 8.
The correct answer is 8 bits.

The `map()` function in Arduino performs linear scaling.

mappedValue = map(value, fromLow, fromHigh, toLow, toHigh)

motorSpeed = map(767, 0, 1023, 0, 255)

The ratio of the input range covered is: $(767 - 0) / (1023 - 0) = 767 / 1023 \approx 0.74975$
The corresponding value in the output range: $0.74975 * (255 - 0) = 0.74975 * 255 \approx 191.18$
Since motor speed is usually an integer, it would be 191.

`analogWrite()` takes a value from 0 to 255.
Duty Cycle = `analogWrite` value / 255 = 127 / 255 $\approx$ 0.498
Average Voltage = Supply Voltage * Duty Cycle

Average Voltage = 5 V * (127 / 255)
Average Voltage ≈ 5 V * 0.4980
Average Voltage ≈ 2.49 V

Therefore, the approximate average voltage across the LED is 2.49 V.

10102 = (1 * 23) + (0 * 22) + (1 * 21) + (0 * 20)
= (1 * 8) + (0 * 4) + (1 * 2) + (0 * 1)
= 8 + 0 + 2 + 0
= 10

Therefore, the decimal equivalent is 10.

`delay()` takes its argument in milliseconds.

1000 milliseconds = 1 second

Therefore, the program will pause for 1 second.

Number of steps = $2^6 = 64$

Resolution = Maximum Output Voltage / Number of Steps
Resolution = 10 V / 64
Resolution ≈ 0.15625 V/step

Therefore, the voltage resolution is approximately 0.15625 V/step.

Total temperature range = 80°C - (-20°C) = 100°C
Number of discrete levels = Total range / Resolution + 1 (to include both endpoints)

Number of levels = 100°C / 1°C + 1 = 100 + 1 = 101 levels

Therefore, it can distinguish 101 discrete temperature levels.