# Lab: TK04 Push Button Control ## **Objective** Learn to read digital input from the TinkerBlock TK04 Push Button module. The button's built-in LED will light when pressed, and we'll use Serial communication to monitor button states. ## **Learning Outcomes** - Understand digital input concepts - Learn about pull-down resistors and active-high signals - Master the **digitalRead()** function - Use Serial communication for debugging and monitoring ## **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 TK04 - Push Button** - Push button module with 4-pin connector ## **Theory** ### **Digital Input** - **Digital Input**: Arduino receives signals from external devices (like buttons) - **Purpose**: Allows Arduino to sense the state of external components - **Values**: Can read HIGH (5V) or LOW (0V) from connected devices ### **Push Button Basics** A push button is a simple mechanical switch that: - **Open State**: No electrical connection between terminals - **Closed State**: Electrical connection between terminals when pressed - **Bounce**: Mechanical switches can create multiple rapid on/off signals ### **Active-High vs Active-Low** - **Active-High**: Signal is HIGH (5V) when button is pressed, LOW (0V) when released - **Active-Low**: Signal is LOW (0V) when button is pressed, HIGH (5V) when released ### **Pull-Down Resistor** - **Purpose**: Ensures a defined logic level when button is not pressed - **Function**: Pulls the signal line to ground (LOW) when button is open - **Value**: 10kΩ resistor provides stable reference without excessive current draw - **TK04 Built-in**: The TK04 module includes a built-in 10kΩ pull-down resistor, eliminating the need for external components ### **Key Functions Used** - **pinMode(pin, mode)**: Configures a pin as input or output - **digitalRead(pin)**: Reads the state of a digital pin (HIGH or LOW) - **Serial.begin(baud)**: Initializes serial communication - **Serial.print()** and **Serial.println()**: Outputs data to Serial Monitor - **delay(milliseconds)**: Pauses the program for a specified time ## **Circuit Diagram** ``` Lonely Binary UNO R3 ↓ TinkerBlock UNO R3 Shield ↓ TinkerBlock TK04 - Push Button Module ``` ## **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 Push Button Module:** - Take the TinkerBlock TK04 - Push Button 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 - **Signal** pin to digital pin D5 3. **Important Notes:** - No breadboard or jumper wires required - The TK04 push button has a built-in 10kΩ pull-down resistor - The button's built-in LED will light when pressed ## **Code** ```cpp // Lab 3: Push Button Control // Push button connected to digital pin D5 // Define the button pin const int buttonPin = 5; // Button input pin void setup() { // Configure button pin as input pinMode(buttonPin, INPUT); // Initialize serial communication for debugging Serial.begin(9600); Serial.println("Push Button Lab Started"); Serial.println("Press the button to see the state change"); } void loop() { // Read the button state int buttonState = digitalRead(buttonPin); // Print button state to serial monitor Serial.print("Button State: "); Serial.println(buttonState); // Add descriptive text based on button state if (buttonState == HIGH) { Serial.println("Button is PRESSED"); } // Small delay to prevent too rapid reading delay(100); } ``` ## **Code Explanation** ### **Setup Function** ```cpp void setup() { pinMode(buttonPin, INPUT); Serial.begin(9600); Serial.println("Push Button Lab Started"); } ``` - Configures pin D5 as input for button reading - Initializes serial communication for debugging - Prints startup messages to Serial Monitor ### **Loop Function** ```cpp void loop() { int buttonState = digitalRead(buttonPin); if (buttonState == HIGH) { Serial.println("Button is PRESSED"); } } ``` ### **Button Reading:** - **digitalRead(buttonPin)**: Reads the state of pin D5 - Returns **HIGH** (1) when button is pressed - Returns **LOW** (0) when button is not pressed ### **Serial Output:** - **if (buttonState == HIGH)**: Checks if button is pressed - Prints descriptive messages based on button state - Provides clear feedback about button status ### **Serial Communication** - **Serial.begin(9600)**: Starts serial communication at 9600 baud - **Serial.print()** and **Serial.println()**: Output debug information - Useful for monitoring button states and troubleshooting ## **Testing and Verification** 1. **Upload the code to Lonely Binary UNO R3** 2. **Open Serial Monitor** in Arduino IDE (Tools → Serial Monitor) 3. **Observe the behavior:** - When button is not pressed: Serial shows "Button State: 0" and "Button is NOT PRESSED" - When button is pressed: Serial shows "Button State: 1" and "Button is PRESSED" - The button's built-in LED should light when pressed 4. **Verify connections:** - Ensure the TK04 module is firmly connected to the shield - Check that the shield is properly seated on the Arduino - Confirm the button's built-in LED is visible and not obstructed ## **Troubleshooting** ### **Button doesn't respond:** - Check if the TinkerBlock shield is properly seated on the Arduino - Ensure the TK04 module is firmly connected to the shield - Verify the module is connected to a slot that uses D5 pin - Check if code uploaded successfully to the Lonely Binary UNO R3 - Open Serial Monitor to see if button states are being read ### **Button reads incorrectly:** - Check Serial Monitor for unexpected button state values - Verify the button module is connected to the correct pin (D5) - Try reconnecting the TK04 module to a different 4-pin slot - Check for loose connections between shield and Arduino ### **Button's built-in LED doesn't light:** - Check if the TK04 module is properly powered (VCC and GND connections) - Verify the module is firmly seated in the shield - Try reconnecting the module to a different 4-pin slot ### **Serial Monitor shows no output:** - Ensure Serial Monitor is set to 9600 baud rate - Check that **Serial.begin(9600)** is in setup() - Verify the correct COM port is selected in Arduino IDE ## **Experiment Variations** ### **1. Button Press Counter** Count and display the number of button presses: ```cpp int buttonPressCount = 0; int lastButtonState = LOW; void loop() { int buttonState = digitalRead(buttonPin); // Detect button press (transition from LOW to HIGH) if (buttonState == HIGH && lastButtonState == LOW) { buttonPressCount++; Serial.print("Button pressed! Total presses: "); Serial.println(buttonPressCount); } lastButtonState = buttonState; delay(50); // Debounce delay } ``` ### **2. Button Hold Detection** Detect how long the button is held: ```cpp unsigned long pressStartTime = 0; bool buttonWasPressed = false; void loop() { int buttonState = digitalRead(buttonPin); if (buttonState == HIGH && !buttonWasPressed) { // Button just pressed pressStartTime = millis(); buttonWasPressed = true; Serial.println("Button pressed - timing started"); } else if (buttonState == LOW && buttonWasPressed) { // Button released unsigned long holdTime = millis() - pressStartTime; Serial.print("Button held for: "); Serial.print(holdTime); Serial.println(" milliseconds"); buttonWasPressed = false; } delay(10); } ``` ### **3. Button State with Timestamp** Add timestamps to button state changes: ```cpp int lastButtonState = LOW; void loop() { int buttonState = digitalRead(buttonPin); if (buttonState != lastButtonState) { unsigned long currentTime = millis(); if (buttonState == HIGH) { Serial.print("Button PRESSED at: "); Serial.print(currentTime); Serial.println(" ms"); } else { Serial.print("Button RELEASED at: "); Serial.print(currentTime); Serial.println(" ms"); } lastButtonState = buttonState; } delay(10); } ``` ## **Questions for Understanding** 1. What is the difference between **digitalRead()** and **digitalWrite()**? 2. Why do we need a pull-down resistor with the push button? 3. What does "active-high" mean for the button signal? 4. How does the built-in LED on the TK04 module work? 5. What is button bounce and how can it affect your program? 6. Why do we use **delay(100)** in the main loop? 7. What is the purpose of Serial communication in this lab? 8. How can you detect a button press vs. button hold? ## **Next Steps** - Try connecting multiple TK04 push buttons to different 4-pin slots - Experiment with different button control patterns - Learn about button debouncing techniques - Explore other TinkerBlock input modules (sensors, switches) - Try combining button input with LED output for interactive projects - Learn about interrupt-based button handling ## **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 TK04 module prevents component damage - Keep the Lonely Binary UNO R3 and shield in a stable position during operation