Exercise 1: Vary the LED Brightness (15 minutes)¶

1. Start by connecting the 5V pin output and GND pin of the Arduino to the red and blue "power rails" of your breadboard. This is good practice while using a breadboard.
2. LEDs are directional components, so ensure that the cathode is connected to ground (see diagram below). Connect the 330Ω resistor to the other lead, and connect the resistor to pin 5 of the Arduino using a jumper wire.
3. Check your circuit against the diagram below. Leave the circuit constructed throughout the session.

4. With this circuit hooked up, you can test its operation. Add to the code below to repeatedly ramp up the brightness of LED from off to fully on over a few seconds each time. You'll need the analogWrite function as well as the delay function. HINT: you can also use a 'for' loop to vary the input to the analogWrite function smoothly. Note that the pin number for the LED has been specified via a preprocessor macro. This is a special statement that literally substitutes each occurence of LED_PIN with the value 5, saving some of the limited memory in the microcontroller.

#define LED_PIN 5

void setup() {
    pinMode(LED_PIN, OUTPUT);
}

void loop() {
    // add code here
}

Exercise 2: Read from the Photocell (15 minutes)¶

1. Leave the 5V and GND connections from the LED example intact, then place one of the photocell leads on the 5V rail. A photocell is essentially a resistor, so its orientation in the circuit doesn't matter.
2. Bend the photocell's leads to 90° so that it faces the LED.
3. Connect the other lead of the photocell to the 4.7kΩ resistor which goes to GND.
4. Use a jumper wire to connect the junction between the photocell and the 4.7kΩ resistor to the Arduino's A0 pin.
5. Check your circuit against the diagram above.
6. Create a new sketch using the Arduino IDE and replace it with the following code. Write your own statements to read in the input value (10-bit unsigned int), cast (convert) that reading to a floating point value, convert the brightness value into voltage using the formula above then print the voltage to the serial port. You will need to make use of the analogRead and Serial.println functions.

#define SENSOR_PIN A0

void setup() {
    Serial.begin(9600);
    pinMode(SENSOR_PIN, INPUT);
}

void loop() {
    // add code here

    delay(50);
}

7. Once the code is uploaded and running, use the Arduino IDE's serial monitor or serial plotter to view the values being read. What happens to the voltage if you cast shadows over the circuit?
8. Allow the voltage to settle to a steady value. Use the serial monitor to record the numerical value. This voltage corresponds to the ambient brightness in the room.

Excercise 3: Finding a Setpoint (5 minutes)¶

1. Start with the photocell reading code you finished.
2. Add to that sketch the code for setting up the LED (refer to the first code listing for help), then use the analogWrite function inside setup to turn the LED on at 30% duty cycle.
3. Run the sketch and observe the voltage output by the photocell circuit. Write this value down as this will be the desired brightness level we will seek to achieve with an automatic control system.

Exercise 4: Implement a Proportional Controller (15 minutes)¶

1. Create a new sketch based on the code below. You will need to replace the value of r with the setpoint you found in the previous exercise, and you will have to implement the controller equations inside loop to find y, e, and u. For now, leave \(K_{p} = 0\) and use \(u(t) = K_p e(t)\).

#define SENSOR_PIN A0
#define LED_PIN 5

// desired voltage (change this to the value you found)
float r = 2;

// proportional controller coefficient (change to tune controller)
float Kp = 0;

// Initialize Global variables
// reading from the photocell
float y = 0;
// error between the desired output and the reading
float e = 0;
// output to send to the LED
float u = 0;

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

void loop() {


    // store your measured voltage in this variable
    y =

    // compute the error between the measurement and the desired value
    e =

    // compute the control effort by multiplying the error by Kp
    u =

    // make sure the output value is bounded to 0 to 255 using the bound function defined below

    u = bound(u, 0, 255);
    analogWrite(LED_PIN, u); // then write it to the LED pin to change control voltage to LED

    // plot the measurement
    Serial.print(y);
    Serial.print('\t');
    // plot the desired output
    Serial.print(r);
    Serial.print('\t');
    // plot the error
    Serial.println(e);

    delay(50);
}

// Bound the input value between x_min and x_max.
float bound(float x, float x_min, float x_max) {
    if (x < x_min) { x = x_min; }
    if (x > x_max) { x = x_max; }
    return x;
}

2. Once the code is uploaded and running, open up the serial plotter. The series of Serial.print statements in the code plots the measurement signal \(y(t)\), the reference signal \(r(t)\) (constant), and the error signal \(e(t)\). Perturb the brightness reading of the photocell by casting shadows on it and figure out which line is which.
3. Let the signals become steady, then use the error measurement to make an estimate of what \(K_{p}\) should be to drive the error to zero. Recall that the reference value was found by producing a PWM signal at 30% duty cycle, so the term \(u(t) = K_{p}e(t)\) should be approximately \(0.3 \times 255 = 76.5\). If \(u(t)\) should be 76.5, what should \(K_{p}\) be? This initial guess will likely produce a proportional constant that is too high and causes instability. Divide it by 2 to start and try different values. Note the steady state error.
4. Now try casting shadows over the circuit. Looking at the LED itself, does it seem to compensate when less light from the ambient environment hits the photocell? What do you observe when looking at the error signal in the serial plotter?

Exercise 5: Adding Integral Control (15 minutes)¶

As you probably have noticed, proportional controllers may suffer from non-zero steady state error. That is, there is a consistent mismatch between the desired and measured outputs, but the controller does not compensate for it exactly. To fix this problem, we can implement an integral control component, which adds to the controller output a multiple of the total integral of the error over all time. If a small but steady error is present, the integral of this error over time will become large, and the integral component of the controller will increase the total controller output to drive the error down to zero.

1. Starting with the code you wrote to implement the proportional controller, introduce a global variable \(K_{i}\) and set it to an order of magnitude smaller than \(K_{p}\).
2. Introduce a variable to keep track of the total accumulation of error. Each time the error is calculated, add it to the current value of the error accumulator variable.
3. Modify the line that computes the PWM control value to use the full control equation:

4. Upload the sketch and open the serial plotter. What happens if you cast shadows on the circuit now?
5. Play around with \(K_p\) and \(K_i\). What does increasing or decreasing these coefficients do? Compare your observations to some of the information on Wikipedia's extensive article on PID control