Skip to content

10. Output devices

This week, our instructor introduced us to different types of output devices and their applications. We explored how they function, interact with circuits, and consume power. To deepen our understanding, we conducted measurements to analyze the efficiency and behavior of different components using a laboratory power supply, a multimeter, and a current sensor.

Group Assignment

Testing and Measuring the LED Strip

We started with an LED strip, connecting it to a power supply and gradually increasing the voltage from 1V to 13V while monitoring its behavior:

  • At 6V, the strip started emitting light, but very dimly.

  • At 12V, it worked as expected, drawing around 0.3A of current.

  • At 13V, its brightness increased, along with power consumption, suggesting that exceeding the rated voltage could lead to overheating or reduced lifespan.

These measurements demonstrated how voltage affects brightness and efficiency, which is crucial when designing lighting or power-saving systems.

Examining and Measuring a DC Motor

Next, we tested a 12V DC motor, focusing on its power consumption in different operating conditions:

  • At startup, the motor drew a high inrush current of around 1.2A, which quickly stabilized as the motor reached its normal operating speed.

  • During continuous operation, the motor consumed approximately 0.8A, depending on the load.

  • These measurements highlighted how motors require more power at startup, a key consideration for designing efficient circuits and power management systems.

Using the ACS712 Current Sensor for Precise Measurements

To get more detailed and real-time data, we used the ACS712 current sensor:

  • We connected the sensor to our circuit and used a microcontroller to read real-time current values.

  • This allowed us to observe small fluctuations in power consumption based on load changes.

  • By analyzing the collected data, we gained insights into how different output devices impact overall system efficiency.

This week’s experiments helped us understand how to analyze and optimize output devices based on their power consumption. We learned to use proper measurement tools, recognize patterns in energy usage, and make informed decisions to improve efficiency and reliability in electronic systems.

Individual assignment

As part of my individual assignment, I decided to combine the results of tests conducted in previous weeks. For automatic control of the water pump, I used the board from Electronics Production week and the YF-S201 flow sensor from Input Devices week.

How It Works

The YF-S201 sensor measures the volume of flowing water. When 0.5 liters have been supplied, the pump automatically turns off.

First, I measured the pump's operation without water supply. For this, a laboratory power supply set to 12 volts was used. At this voltage, the pump consumes 0.13 Amps. These data served as a starting point for evaluating the pump's performance under no-load conditions.

Next, based on these values, I continued testing with the water supply to compare the current consumption in different operating modes of the pump. This allowed me to observe how the energy consumption changes when the pump operates with water.

After that, I made some modifications to the code for the sensor, adding a function to automatically turn off the pump when a certain amount of water is reached.

Previously, the code simply read data from the water flow sensor and displayed it in the Serial Monitor, but it did not control the pump. Now, I made changes that allow the system to control the water flow automatically.

I added a check if (totalFlow >= 0.5), which compares the total amount of water used with the set limit of 0.5 liters. Once this volume is reached, the pump automatically turns off, preventing further water flow.

After the water flow stops, there is a 10-second delay before the pump starts again. This delay is chosen purely for the sake of the experiment's visibility and is not essential for the entire system. Here is the part of the code where the delay is implemented:

if (totalFlow >= 0.5) {
    digitalWrite(PUMP_PIN, LOW); // Turn off the pump
    delay(10000); // Wait 10 seconds before restarting
}

This improvement made the system smarter and more convenient. Now, it doesn't require constant monitoring and manual control, as it automatically stops the water flow once the set value is reached. This is important for controlling water consumption and improving the efficiency of the device.

In the future, I will need to modify the code to add a function for automatically draining the water from the reservoir and pumping it back. This will create circulation of water in the hydroponic system, ensuring continuous supply of nutrients to the plants.

Here is the fully modified code

// Define the pin for the water flow sensor
#define SENSOR_PIN 26

// Define the pin for controlling the pump
#define PUMP_PIN 2

// Variable to store the number of pulses from the sensor
volatile int pulseCount = 0;

// Variable to store the current water flow rate (liters per minute)
float flowRate;

// Variable to store the time of the previous measurement
unsigned long previousMillis = 0;

// Variable to store the total amount of water used
float totalFlow = 0;

// Interrupt handler function, increments the pulse counter
void pulseCounter() {
    pulseCount++; // Increase the pulse count by 1
}

void setup() {
    Serial.begin(9600); // Initialize the serial port at 9600 baud

    pinMode(SENSOR_PIN, INPUT_PULLUP); // Set the sensor pin as input with an internal pull-up resistor

    // Configure an interrupt: on a falling signal on SENSOR_PIN, call the pulseCounter function
    attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), pulseCounter, FALLING);

    pinMode(PUMP_PIN, OUTPUT); // Set the pump pin as an output
}

void loop() {
    digitalWrite(PUMP_PIN, HIGH); // Turn on the pump

    // Check if 1000 ms (1 second) has passed since the last measurement
    if (millis() - previousMillis >= 1000) {
        detachInterrupt(digitalPinToInterrupt(SENSOR_PIN)); // Disable the interrupt during calculations

        // Calculate the water flow rate: 7.5 pulses correspond to 1 liter per minute
        flowRate = (pulseCount / 7.5);

        pulseCount = 0; // Reset the pulse count
        previousMillis = millis(); // Update the last measurement time

        // Add the current flow rate (divided by 50) to the total flow (since updates happen every second)
        totalFlow += flowRate / 50;

        // Print the current flow rate to the Serial Monitor
        Serial.print("Flow Rate: ");
        Serial.print(flowRate);
        Serial.println(" L/min");

        // Print the total amount of water used
        Serial.print("Total Flow: ");
        Serial.print(totalFlow);
        Serial.println(" L");

        attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), pulseCounter, FALLING); // Re-enable the interrupt

        // If the total water usage exceeds 0.5 liters, turn off the pump
        if (totalFlow >= 0.5) {
            digitalWrite(PUMP_PIN, LOW); // Turn off the pump
            delay(10000); // Wait 10 seconds before turning it back on
        }
    }
}

During the system testing, it can be observed that the readings change when water is flowing. Instead of the initial 0.13 amps, which the pump consumed without water, the pump now consumes an average of 0.27 amps. This change is due to the pump working with water, which increases the load on its motor.

Additionally, in the video, you can see bubbles of water appearing in the hose coming from the sensor. This is likely due to insufficient suction power of the pump. However, I believe this small discrepancy will not significantly affect the accuracy of the readings or the system's performance.