KY-020 Tilt Switch Module
View on Amazon
Overview
About KY-020 Tilt Switch Module
The KY-020 Tilt Switch Module is designed to detect orientation or inclination. It contains a metallic ball that connects or disconnects the circuit depending on the module’s tilt angle. When tilted, the ball moves, closing or opening the circuit, which can be read as a digital signal by microcontrollers like the Arduino or ESP32. This module operates at voltages between 3.3V and 5V, making it versatile for various projects.
Get Your KY-020
Starting from
1$ per unit
Prices are subject to change. We earn from qualifying purchases as an Amazon Associate.
KY-020 Specifications
Complete technical specification details for KY-020 Tilt Switch Module
📊 Technical Parameters
KY-020 Pinout
The **KY-020** is a 3-pin ball tilt switch sensor module:
Visual Pinout Diagram
Pin Types
Quick Tips
**Interface**: Digital output (tilt/orientation detection),🎯 **Sensor**: Metallic ball switch mechanism
**Operation**: Ball moves with tilt, connecting or disconnecting circuit,⚡ **Power**: 3.3V to 5V operation
**Binary**: Simple binary tilt detection (on/off),🎯 **Applications**: Orientation detection, motion sensors, anti-theft alarms, tilt-based controls
Pin Descriptions
| Pin Name | Type | Description | Notes |
|---|---|---|---|
1 Pin (-) | Power | Ground connection | |
2 Pin (middle) | Power | Power supply | 3.3V to 5V |
3 Pin (S) | Communication | Digital signal output | Changes state when tilted |
Wiring KY-020 to ESP32
To interface the **KY-020** with an **ESP32** for tilt detection:
Visual Wiring Diagram
Connection Status
Protocol
Pin Connections
| KY-020 Pin | Connection | ESP32 Pin | Description |
|---|---|---|---|
1 Pin (-) Required | GND | Ground | |
2 Pin (middle) Required | 3.3V | Power supply | |
3 Pin (S) Required | GPIO4 | Digital input (any GPIO) |
**GPIO Selection**: Any digital GPIO pin works, GPIO4 is just an example
**Voltage**: Use 3.3V for ESP32 compatibility
**Ball Switch**: Physical ball moves inside to make/break contact
**Binary Output**: Simple HIGH/LOW state based on tilt angle
**Safer Alternative**: Consider using KY-017 mercury-free version for environmental safety
KY-020 Troubleshooting
Common issues and solutions to help you get your sensor working
Common Issues
Issue: The sensor does not output any signal when tilted.
Solutions:
- Verify that all connections are secure and correctly placed.
- Ensure the module is receiving the appropriate voltage (3.3V to 5V).
- Check if the microcontroller's digital input pin is correctly configured.
Issue: The sensor outputs a signal without being tilted.
Solutions:
- Ensure stable mounting to prevent unintended movements.
- Check for loose connections or interference from nearby electronic components.
- Implement software debouncing to filter out spurious signals.
Debugging Tips
Use the Serial Monitor to check for error messages and verify the sensor's output. Add debug prints in your code to track the sensor's state.
Use a multimeter to verify voltage levels and check for continuity in your connections. Ensure the power supply is stable and within the sensor's requirements.
Additional Resources
KY-020 Programming Examples
Ready-to-use code examples for different platforms and frameworks
int tilt_switch = 10; // Declaration of the sensor input pin
int value; // Temporary variable
void setup() {
pinMode(tilt_switch, INPUT); // Initialization sensor pin
Serial.begin(9600); // Initialization of the serial monitor
Serial.println("KY-020 Inclination test");
}
void loop() {
// The current signal at the sensor is read out
value = digitalRead(tilt_switch);
// If a signal could be detected, this is displayed on the serial monitor.
if (value == LOW) {
Serial.println("Inclination recognized");
delay(1000); // 1s break
}
}This Arduino code sets up the KY-020 tilt switch on digital pin 10. It reads the digital value corresponding to the tilt state and prints a message to the serial monitor when an inclination is detected.
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#define TILT_SWITCH_PIN GPIO_NUM_4
void app_main(void) {
gpio_config_t io_conf = {
.pin_bit_mask = (1ULL << TILT_SWITCH_PIN),
.mode = GPIO_MODE_INPUT,
.pull_up_en = GPIO_PULLUP_ENABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE
};
gpio_config(&io_conf);
printf("KY-020 Tilt Switch Test\n");
while (1) {
int level = gpio_get_level(TILT_SWITCH_PIN);
if (level == 0) {
printf("Inclination recognized\n");
vTaskDelay(pdMS_TO_TICKS(1000)); // 1s delay
}
vTaskDelay(pdMS_TO_TICKS(100));
}
}This ESP-IDF code configures GPIO4 as an input with an internal pull-up resistor for the KY-020 tilt switch. It continuously checks the pin state and prints a message when an inclination is detected.
binary_sensor:
- platform: gpio
pin:
number: GPIO4
mode: INPUT_PULLUP
name: "KY-020 Tilt Switch"
filters:
- delayed_on: 50ms
- delayed_off: 50ms
on_press:
- then:
- lambda: |-
ESP_LOGD("sensor", "Inclination recognized!");This ESPHome configuration sets up the KY-020 tilt switch as a binary sensor on GPIO4 with an internal pull-up resistor enabled. Debouncing filters are applied to avoid false triggers. When the sensor detects an inclination, a log message is recorded.
platformio.ini
[env:esp32]
platform = espressif32
board = esp32dev
framework = arduinomain.cpp
#include <Arduino.h>
#define TILT_SWITCH_PIN 4
void setup() {
pinMode(TILT_SWITCH_PIN, INPUT_PULLUP);
Serial.begin(115200);
Serial.println("KY-020 Tilt Switch Test");
}
void loop() {
if (digitalRead(TILT_SWITCH_PIN) == LOW) {
Serial.println("Inclination recognized");
delay(1000);
}
delay(100);
}This PlatformIO code configures GPIO4 as an input with a pull-up resistor for the KY-020 tilt switch. It detects inclination changes and prints a message when a tilt is recognized.
import machine
import time
TILT_SWITCH_PIN = machine.Pin(4, machine.Pin.IN, machine.Pin.PULL_UP)
while True:
if TILT_SWITCH_PIN.value() == 0:
print("Inclination recognized")
time.sleep(1)
time.sleep(0.1)This MicroPython script configures GPIO4 as an input with an internal pull-up resistor for the KY-020 tilt switch. It continuously checks the sensor state and prints a message when an inclination is detected.
Wrapping Up KY-020
The ESP32 KY-020 Tilt Switch Module is a powerful KY-0xx module sensor that offers excellent performance and reliability. With support for multiple development platforms including Arduino, ESP-IDF, ESPHome, PlatformIO, and MicroPython, it's a versatile choice for your IoT projects.
Best Practices
For optimal performance, ensure proper wiring and follow the recommended configuration for your chosen development platform.
Safety First
Always verify power supply requirements and pin connections before powering up your project to avoid potential damage.
Ready to Start Building?
Now that you have all the information you need, it's time to integrate the KY-020 into your ESP32 project and bring your ideas to life!
Explore Alternative Sensors
Looking for alternatives to the KY-020? Check out these similar sensors that might fit your project needs.
KY-023 Dual Axis Joystick Module
The KY-023 is a dual-axis joystick module that provides analog outputs for X and Y positions, along with a digital output for a built-in...
KY-026 Flame Sensor Module
The KY-026 is a flame sensor module capable of detecting light in the 760 nm to 1100 nm wavelength range. It offers both analog and digital...
KY-053 Analog Digital Converter Module
The KY-053 is an analog-to-digital converter module featuring the ADS1115 ADC. It provides four 16-bit resolution channels and communicates...