Electronic Input Devices

We learned about the concept of voltage dividers, capacitance, and calibration. We also covered different kinds of capacitive sensors: potentiometers, thermistors, force sensors, light sensors, and more!

Capacitive Sensor

The first assignment was to make a capacitive sensor to measure a physical quantity with your microcontroller. I decided to measure the water level in a container. I stuck two strips of copper tape to opposite sides of the container, forming the plates of my capacitor.

The first iteration of my code came from the capacitive sensor we made during class that used transmit-receive (tx-rx).

long result;   // Variable for the result of the tx_rx measurement.
int analog_pin = A3;
int tx_pin = 4;

void setup() {
    pinMode(tx_pin, OUTPUT);      // Pin 4 provides the voltage step
    Serial.begin(9600);
}

void loop() {
    result = tx_rx();
    Serial.println(result);
}


long tx_rx(){         // Function to execute rx_tx algorithm and return a value
                      // that depends on coupling of two electrodes.
                      // Value returned is a long integer.
    int read_high;
    int read_low;
    int diff;
    long int sum;
    int N_samples = 500;    // Number of samples to take.  Larger number slows it down, but reduces scatter.

    sum = 0;

    for (int i = 0; i < N_samples; i++){
        digitalWrite(tx_pin,HIGH);              // Step the voltage high on conductor 1.
        read_high = analogRead(analog_pin);     // Measure response of conductor 2.
        delayMicroseconds(100);                 // Delay to reach steady state.
        digitalWrite(tx_pin,LOW);               // Step the voltage to zero on conductor 1.
        read_low = analogRead(analog_pin);      // Measure response of conductor 2.
        diff = read_high - read_low;            // Desired answer is the difference between high and low.
        sum += diff;                            // Sums up N_samples of these measurements.
    }
    
    return sum / N_samples;
}
                

In the second iteration of my code, I replaced delay with micros and created a Capacitive class.

class Capacitive {
    public:
    int analog_pin;
    int tx_pin;
    long result = 0; // Variable for the result of the tx_rx measurement.
    long int sum = 0;
    int N_samples = 1000;    // Number of samples to take.  Larger number slows it down, but reduces scatter.
    int N = 0;
    int step = 0;
    unsigned long startTime;
    int read_high;
    
    Capacitive(int pin1, int pin2) {
        analog_pin = pin1;
        tx_pin = pin2;
        pinMode(tx_pin, OUTPUT);      // Pin 4 provides the voltage step
    }
    
    long tx_rx(){        // Function to execute rx_tx algorithm and return a value
                        // that depends on coupling of two electrodes.
                        // Value returned is a long integer.
        if (N < N_samples) {
            if (step == 0) {
                startTime = micros();
                digitalWrite(tx_pin,HIGH);              // Step the voltage high on conductor 1.
                read_high = analogRead(analog_pin);     // Measure response of conductor 2.
                step = 1;
            }
            else if ((step == 1) && (micros() - startTime > 100)) {
                digitalWrite(tx_pin,LOW);               // Step the voltage to zero on conductor 1.
                int read_low = analogRead(analog_pin);  // Measure response of conductor 2.
                int diff = read_high - read_low;        // Desired answer is the difference between high and low.
                sum += diff;                            // Sums up N_samples of these measurements.
                N++;
                step = 0;
            }
        }
        else if (N == N_samples) {
            result = sum / N_samples;
            N = 0;
            sum = 0;
        }
        return result;
    }
};

Capacitive capacitive(A3, 4);

void setup() {
    Serial.begin(9600);
}

void loop() {
    Serial.println(capacitive.tx_rx());
}
                

The numbers in the serial monitor fluctuated quite a bit at times, even after taking the average of 1000 samples for each data point, so I roughly found the midpoint of the range of numbers I saw for each water level. Sometimes, the number would jump to 1020-1023, which I thought were erroneous measurements--maybe the voltage difference was too high--since that is the upper bound of the possible values of analogRead. In addition, the numbers were sensitive to when I touched any part of the setup, when the wires accidentally touched the container, etc.

Despite these obstacles to robust measurements, I still got a reasonable increasing relationship between the height of the water and the difference in signals between the two plates. This makes sense because the permittivity of water (80) is higher than the permittivity of air (~1).

Another Sensor

The second assignment was to configure and use another sensor, and include at least one output device. Since I need to measure distance from walls in my final project, I decided to use the ultrasonic distance sensor. The sensor works by sending out a signal from the transmitter and then listening for a response in the receiver. It only senses objects within a particular field of view.

To test, I placed my cardboard box from Week 1 in front of the sensor and moved it forwards and backwards. Here is what my setup looked like, as well as a schematic of my circuit:

The first iteration of my code was able to reliably measure the distance. It works by first setting the Trigger pin LOW and then setting it HIGH to initiate the trigger pulse. After 10 microseconds, you set it LOW again to end the trigger pulse. You then use the pulseIn() function to measure the length of the pulse on the Echo pin. Finally, you do the math to convert the pulse time to distance in centimeters.

const int trigPin = 9;
const int echoPin = 10;

void setup() {
    pinMode(trigPin, OUTPUT);
    pinMode(echoPin, INPUT);
    Serial.begin(9600);
}

void loop() {
    digitalWrite(trigPin, LOW); // Set the Trigger pin LOW to start a pulse
    delayMicroseconds(2);
    digitalWrite(trigPin, HIGH); // Set the Trigger pin HIGH
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW); // Set the Trigger pin LOW again to complete the pulse
    
    long duration = pulseIn(echoPin, HIGH); // Listen for a pulse on the Echo pin
    Serial.print("Duration: ");
    Serial.println(duration);
    delay(10); // Delay between readings
}
                

I then refactored the code to use the C++ class structure, creating an Ultrasonic class with functions to sendSignal and measureSignal.

class Ultrasonic {
    public:
    int trigPin;
    int echoPin;
    float distance;
    
    Ultrasonic(int pin1, int pin2) {
        trigPin = pin1;
        echoPin = pin2;
        pinMode(trigPin, OUTPUT);
        pinMode(echoPin, INPUT);
    }
    
    void sendSignal() {
        digitalWrite(trigPin, LOW); // Set the Trigger pin LOW to start a pulse
        delayMicroseconds(2);
        digitalWrite(trigPin, HIGH); // Set the Trigger pin HIGH
        delayMicroseconds(10);
        digitalWrite(trigPin, LOW); // Set the Trigger pin LOW again to complete the pulse
    }
    
    int measureSignal() {
        long duration = pulseIn(echoPin, HIGH); // Listen for a pulse on the Echo pin
        Serial.print("Duration: ");
        Serial.println(duration);
        return duration;
    }
};
    
void setup() {
    Serial.begin(9600);
}
    
Ultrasonic ultrasonic(9, 10);
float distance = 0;

void loop() {
    ultrasonic.sendSignal();
    distance = ultrasonic.measureSignal();
}
                    

However, the code used the delay() function, so I replaced it with micros(). This involved creating a measured variable with 4 possible values that tracked which step of the process I was in.

class Ultrasonic {
    public:
    int trigPin;
    int echoPin;
    float distance;
    int signalInterval;
    unsigned long signalStartTime;
    int measured = 3;

    Ultrasonic(int pin1, int pin2, int interval) {
        trigPin = pin1;
        echoPin = pin2;
        signalInterval = interval; // in microseconds
        pinMode(trigPin, OUTPUT);
        pinMode(echoPin, INPUT);
    }

    void sendSignal() {
        if ((micros() - signalStartTime > signalInterval) && (measured == 3)) {
            signalStartTime = micros();
            digitalWrite(trigPin, LOW); // Set the Trigger pin LOW to start a pulse
            measured = 2;
        }
        else if ((micros() - signalStartTime > 2) && (measured == 2)) {
            digitalWrite(trigPin, HIGH); // Set the Trigger pin HIGH
            measured = 1;
        }
        else if ((micros() - signalStartTime > 12) && (measured == 1)) {
            digitalWrite(trigPin, LOW); // Set the Trigger pin LOW again to complete the pulse
            measured = 0; // Signal is done so ready to measure
        }
    }

    int measureSignal() {
        if ((micros() - signalStartTime > signalInterval) && (measured == 0)) {
            long duration = pulseIn(echoPin, HIGH); // Listen for a pulse on the Echo pin
            Serial.print("Duration: ");
            Serial.println(duration);
            measured = 3;
            return duration;
        }
    }
};

void setup() {
    Serial.begin(9600);
}

Ultrasonic ultrasonic(9, 10, 1000);

void loop() {
    ultrasonic.sendSignal();
    ultrasonic.measureSignal();
}
                    

Finally, I added an output device--an LED that would get brighter as the box moved farther away. I converted the measured pulse duration (in microseconds) to brightness (which ranges from 0 to 255) by dividing by 15, but this factor was an arbitrary choice (within reasonable limits). The final code with a new Led class is below.

class Ultrasonic {
    public:
    int trigPin;
    int echoPin;
    float distance;
    int signalInterval;
    unsigned long signalStartTime;
    int measured = 3;

    Ultrasonic(int pin1, int pin2, int interval) {
        trigPin = pin1;
        echoPin = pin2;
        signalInterval = interval; // in microseconds
        pinMode(trigPin, OUTPUT);
        pinMode(echoPin, INPUT);
    }

    void sendSignal() {
        if ((micros() - signalStartTime > signalInterval) && (measured == 3)) {
            signalStartTime = micros();
            digitalWrite(trigPin, LOW); // Set the Trigger pin LOW to start a pulse
            measured = 2;
        }
        else if ((micros() - signalStartTime > 2) && (measured == 2)) {
            digitalWrite(trigPin, HIGH); // Set the Trigger pin HIGH
            measured = 1;
        }
        else if ((micros() - signalStartTime > 12) && (measured == 1)) {
            digitalWrite(trigPin, LOW); // Set the Trigger pin LOW again to complete the pulse
            measured = 0; // Signal is done so ready to measure
        }
    }

    int measureSignal() {
        if ((micros() - signalStartTime > signalInterval) && (measured == 0)) {
            long duration = pulseIn(echoPin, HIGH); // Listen for a pulse on the Echo pin
            Serial.print("Duration: ");
            Serial.println(duration);
            measured = 3;
            return duration;
        }
    }
};

class Led {
    public:
    int ledPin;
    int brightness;

    Led(int pin) {
    ledPin = pin;
    pinMode(ledPin, OUTPUT);
    }

    void setBrightness(float distance) {
    float val = distance / 15.0;
    analogWrite(ledPin, val);
    }
};

void setup() {
    Serial.begin(9600);
}

Ultrasonic ultrasonic(9, 10, 1000);
Led led(3);

void loop() {
    ultrasonic.sendSignal();
    float distance = ultrasonic.measureSignal();
    led.setBrightness(distance);  
}
                    

Here is a video of the final result! It is a bit hard to tell in the video that the brightness of the LED is fluctuating, but it was more visible in person. Overall, I was pleasantly surprised by how consistent and reliable the measurements were. The numbers in the serial monitor didn't really fluctuate when the box was still and were not affected by nearby objects (unless they were in the field of view, of course), unlike the capacitive sensor.

For the ultrasonic sensor, the relationship between the duration of the pulses recorded by the microcontroller and the physical distance between the sensor and the box appears to be approximately linear.