In this week's group assignment, Aleksi instructed us on how to measure I²C signals using a small time-of-flight rangefinder module, a potentiometer, a light sensor, and a thermistor. It was nice to see how easy it is to integrate these sensors into a device.

Optical gate sensor

This week’s individual task was to design a sensor, add it to a microcontroller board, and measure its output. For my final project, I need to detect when a ball goes through the target loop, so I decided to design a sensor for that purpose. An optical gate is the most natural solution for this.

I used the microcontroller board designed during week 6 and manufactured during week 8. To build a prototype of the optical gate, I used perfboards.

Before starting the design in KiCad, I did a git pull for the Fab Electronics Library, since it’s under active development:

cd c:/kicad/libraries/kicad

git pull

I used a standard HIR11_21C/L11/TR8 IR LED from the Fab Lab inventory. The maximum current rating for this LED is 65 mA, so I placed a 100 ohm resistor in series to ensure it doesn't exceed that when driven with a 5 V signal.

For light detection, I used a phototransistor in combination with a pull-up resistor to convert changes in light into a measurable voltage. When light hits the phototransistor, it alters the current through the resistor, which in turn changes the voltage across it. This voltage is then measured using the microcontroller’s analog-to-digital (A/D) converter.

Based on the datasheet for the PT15-21C/TR8 phototransistor, a rough estimate suggests a current of approximately 0.1 mA when the LED is shining on it from a few centimeters away. Using this estimate, I selected a 10 kΩ resistor at the collector to generate a measurable voltage at the Sense_out pin.

Using a multimeter, I verified that the optoreceiver responded correctly to the LED illumination. The LED was driven with a constant 5 V DC.

I then connected output pin 5 of the ESP32-C3 to drive the LED_drive pin, and sensor pin 4 to the Sense_out pin. The ESP32-C3 gave strange results: the Sense_out values didn’t behave as expected when illuminated, especially under low light conditions.

After some investigation, I realized that the ESP32-C3’s allowed input voltage range is –0.3 V to 3.6 V. In my receiver circuit, when there is no input light, the output pin sits at 5 V and drops when light hits the phototransistor. This means the ESP32-C3 input pin was being overdriven.

To fix this, I needed to modify my PCB by rerouting a wire from the 3.3 V DC output to bias the optoreceiver circuit appropriately:

Ambient light can interfere with this measurement. One solution is synchronous detection: the LED is pulsed (turned on and off rapidly), and the receiver is synchronized with this. Ambient light changes slowly, while the LED signal is modulated at a higher frequency. By continuously subtracting the "off" signal from the "on" signal, the effect of ambient light is eliminated. The synchronous detection can be implemented in software.

To test the circuit quickly and to test the synchronous detection, I asked ChatGPT for suitable code with the prompt "I have an LED and resistor connected to output pin 5 of ESP32-C3 and an optical receiver connected to pin 4. Can you give code to blink the LED slowly and show the detected level during both phases and the synchronous detection level?"

		
#define LED_PIN 5
#define SENSOR_PIN 4

void setup() {
Serial.begin(9600);
pinMode(LED_PIN, OUTPUT);
}

void loop() {
// LED OFF
digitalWrite(LED_PIN, LOW);
delay(500); // long enough to visually confirm LED off
int off = analogRead(SENSOR_PIN);

// LED ON
digitalWrite(LED_PIN, HIGH);
delay(500); // LED visibly on
int on = analogRead(SENSOR_PIN);

int reflected = on - off;

Serial.print("ON: ");
Serial.print(on);
Serial.print("  OFF: ");
Serial.print(off);
Serial.print("  REFLECTED: ");
Serial.println(reflected);
}
		
		

The circuit was now working properly. When the LED is off, the receiver only detects background (ambient) light. In the oscilloscope measurement of the Sense_out pin, even the 50 Hz flickering of the room lights can be seen. If no illumination is detected, the collector of the phototransistor is at 3.3 V.

The microcontroller was also showing reasonable values now. In these values 3.3 V corresponds to the maximum analog-to-digital value of 4095. When the phototransistor is illuminated, the collector voltage and the digital value of pin 4 drops accordingly:

At first, I thought I would need to use synchronous detection. However, it seems that detecting a fast signal drop, within a certain time interval, is a sufficient method to detect when a ball passes through the goal. To quickly test this idea, I turned to ChatGPT with the prompt: "Can I have the LED on all the time and detect if there is a drop in detected signal strength for a duration between 10 microseconds and 1 second? This would help me detect if a ball passes through the optical gate. The analog signal is low when there is no ball between the gate. Can the baseline be checked at a frequency of 1 Hz?"

		
#define LED_PIN 5
#define SENSOR_PIN 4
#define THRESHOLD_DROP 1.05  // Trigger if signal drops 5% of baseline
#define MIN_DURATION 10     // Microseconds
#define MAX_DURATION 1000000 // 1 second

unsigned long lastBaselineUpdate = 0;
const unsigned long baselineInterval = 1000; // ms

int baseline = 0;

void setup() {
	Serial.begin(9600);
	pinMode(LED_PIN, OUTPUT);
	digitalWrite(LED_PIN, HIGH); // LED always on

	baseline = readSensorBaseline();
	Serial.print("Initial baseline: ");
	Serial.println(baseline);
}

void loop() {
	// Update baseline every 1 second
	if (millis() - lastBaselineUpdate >= baselineInterval) {
	int newBaseline = readSensorBaseline();

	// Optional: Only update if no ball is detected
	if (newBaseline < baseline * 1.1) {
		baseline = newBaseline;
		//Serial.print("Updated baseline: ");
		//Serial.println(baseline);
	}

	lastBaselineUpdate = millis();
	}

	int sensorValue = analogRead(SENSOR_PIN);
	unsigned long startTime = 0;

	// Trigger if signal rises (since your signal is normally low)
	if (sensorValue > baseline * THRESHOLD_DROP) {
	startTime = micros();

	while (analogRead(SENSOR_PIN) > baseline * THRESHOLD_DROP) {
		if ((micros() - startTime) > MAX_DURATION) break;
	}

	unsigned long duration = micros() - startTime;

	if (duration >= MIN_DURATION && duration <= MAX_DURATION) {
		Serial.print("Ball detected! Duration: ");
		Serial.print(duration);
		Serial.println(" us");
	}
	}

	delayMicroseconds(100);
}

int readSensorBaseline() {
	const int samples = 10;
	long total = 0;
	for (int i = 0; i < samples; i++) {
	total += analogRead(SENSOR_PIN);
	delay(5); // Small delay between samples
	}
	return total / samples;
}

This slow motion video shows the electronics and code in action, though some tuning is still needed. As Aleksi suggested, I will likely place the receiver inside a cone to improve ambient light rejection.

Design files

Arduino code for the optical gate