Video
# Lab: LED Dimming Control
## **Objective**
Learn to control LED brightness using analog output with the TinkerBlock TK01 - XL LED module. The LED will gradually fade from bright to dim and back, demonstrating PWM (Pulse Width Modulation) control.
## **Learning Outcomes**
- Understand the difference between digital and analog output
- Learn about PWM (Pulse Width Modulation) for LED brightness control
- Master the **analogWrite()** function
- Create smooth fading effects with LEDs
## **Required Components**
1. **Lonely Binary UNO R3** - Main Arduino board
2. **TinkerBlock UNO R3 Shield** - Expansion shield that plugs onto the UNO R3
3. **TinkerBlock TK01 - XL LED** - LED module with 4-pin connector
## **Theory**
### **Digital vs Analog Output**
- **Digital Output**: Can only be HIGH (5V) or LOW (0V) - like a light switch
- **Analog Output**: Can output varying voltage levels (0-5V) - like a dimmer switch
### **PWM (Pulse Width Modulation)**
PWM is a technique used to simulate analog output using digital pins. It works by rapidly switching a digital pin between HIGH and LOW states at different duty cycles:
- **Duty Cycle**: Percentage of time the signal is HIGH
- **Frequency**: How fast the switching occurs (usually too fast for human eye to see)
- **Result**: LED appears to have varying brightness levels
### **Key Functions Used**
- **pinMode(pin, mode)**: Configures a pin as input or output
- **analogWrite(pin, value)**: Outputs PWM signal (0-255) for analog simulation
- **delay(milliseconds)**: Pauses the program for a specified time
## **Circuit Diagram**
## **Connection Instructions**

1. **Assemble the Hardware:**
- Place the TinkerBlock UNO R3 Shield onto the Lonely Binary UNO R3
- Ensure all pins are properly aligned and seated
- The shield should fit snugly on top of the Arduino board
2. **Connect the LED Module:**
- Take the TinkerBlock TK01 - XL LED module
- Align the 4-pin connector with any available 4-pin slot on the shield
- Gently push the module into the slot until it clicks into place
- The module will automatically connect:
- **GND** pin to ground
- **VCC** pin to 5V power
- **NC** pin remains unconnected
- **D3** pin to digital pin D3
## **Code**
```cpp
// Lab 2: LED Dimming Control
// LED connected to digital pin D3 (PWM capable)
// Define the LED pin
const int ledPin = 3;
void setup() {
// Configure pin D3 as output
pinMode(ledPin, OUTPUT);
}
void loop() {
// Fade LED from dim to bright (0 to 255)
for (int brightness = 0; brightness <= 255; brightness++) {
analogWrite(ledPin, brightness);
delay(10); // Small delay for smooth transition
}
// Fade LED from bright to dim (255 to 0)
for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(ledPin, brightness);
delay(10); // Small delay for smooth transition
}
}
```
## **Code Explanation**
### **Setup Function**
```cpp
void setup() {
pinMode(ledPin, OUTPUT);
}
```
- Runs once when Arduino starts
- Configures pin D3 as an output pin
- Same as Lab 1, but now we'll use analogWrite() instead of digitalWrite()
### **Loop Function**
```cpp
void loop() {
// Fade in
for (int brightness = 0; brightness <= 255; brightness++) {
analogWrite(ledPin, brightness);
delay(10);
}
// Fade out
for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(ledPin, brightness);
delay(10);
}
}
```
### **Fade In (0 to 255):**
- **for** loop increases brightness from 0 to 255
- **analogWrite(ledPin, brightness)**: Sets PWM duty cycle
- **delay(10)**: Creates smooth transition (10ms between each brightness level)
### **Fade Out (255 to 0):**
- **for** loop decreases brightness from 255 to 0
- Same process but in reverse direction
### **PWM Values**
- **0**: LED completely off (0% duty cycle)
- **128**: LED at 50% brightness (50% duty cycle)
- **255**: LED at full brightness (100% duty cycle)
## **Testing and Verification**
1. **Upload the code to Lonely Binary UNO R3**
2. **Observe the LED behavior:**
- The XL LED should gradually fade from off to full brightness
- Then gradually fade from full brightness back to off
- This cycle should repeat continuously
3. **Verify connections:**
- Ensure the shield is properly seated on the Arduino
- Check that the TK01 module is firmly connected to the shield
- Confirm the LED is visible and not obstructed
## **Troubleshooting**
### **LED doesn't change brightness:**
- Check if the TinkerBlock shield is properly seated on the Arduino
- Ensure the TK01 module is firmly connected to the shield
- Verify the module is connected to a slot that uses D3 pin (PWM capable)
- Check if code uploaded successfully to the Lonely Binary UNO R3
### **LED flickers or changes brightness abruptly:**
- Check if **delay()** functions are working properly
- Verify pin number in code matches the shield's D3 connection
- Ensure the Lonely Binary UNO R3 is powered consistently
- Try reconnecting the TK01 module to a different 4-pin slot
### **LED is too dim or too bright:**
- Check power supply to the Lonely Binary UNO R3
- Ensure the shield is making good contact with all pins
- Try cleaning the module connector pins if necessary
- Verify the built-in resistor in the TK01 module is working
## **Experiment Variations**
### **1. Change Fading Speed**
Modify the delay values to change fading speed:
```cpp
delay(5); // Faster fading
delay(20); // Slower fading
delay(50); // Much slower fading
```
### **2. Different Brightness Patterns**
Create breathing effect or step patterns:
```cpp
// Breathing effect (exponential fade)
for (int brightness = 0; brightness <= 255; brightness++) {
analogWrite(ledPin, brightness);
delay(brightness / 10); // Slower at higher brightness
}
```
### **3. Multiple Brightness Levels**
Create a step pattern instead of smooth fade:
```cpp
// Step pattern
analogWrite(ledPin, 0); delay(1000); // Off
analogWrite(ledPin, 64); delay(1000); // 25% brightness
analogWrite(ledPin, 128); delay(1000); // 50% brightness
analogWrite(ledPin, 192); delay(1000); // 75% brightness
analogWrite(ledPin, 255); delay(1000); // 100% brightness
```
## **Questions for Understanding**
1. What is the difference between **digitalWrite()** and **analogWrite()**?
2. How does PWM create the illusion of varying brightness?
3. What is the range of values for **analogWrite()** and what do they represent?
4. Why do we need to use a PWM-capable pin for analog output?
5. What would happen if you used **analogWrite()** on a non-PWM pin?
6. How could you create a "breathing" effect with the LED?
## **Next Steps**
- Try connecting multiple TK01 LED modules to different 4-pin slots on the shield
- Experiment with different fading patterns and speeds
- Learn about reading analog input with **analogRead()**
- Explore other TinkerBlock modules that can be controlled with analog output
- Try creating synchronized patterns with multiple LEDs
## **Safety Notes**
- Always disconnect power before connecting or disconnecting modules
- Handle the TinkerBlock shield and modules carefully to avoid bending pins
- Ensure proper alignment when connecting modules to prevent damage
- The built-in resistor in the TK01 module prevents LED damage
- Keep the Lonely Binary UNO R3 and shield in a stable position during operation
---
**Lab Completion Checklist:**
- [ ] TinkerBlock shield properly seated on Lonely Binary UNO R3
- [ ] TK01 LED module connected to shield
- [ ] Code uploaded successfully to Lonely Binary UNO R3
- [ ] LED fades smoothly from off to bright and back
- [ ] Troubleshooting completed (if needed)
- [ ] Experiment variations tried
- [ ] Questions answered