Team SERVO MOTOR CONTROLLER 4B:

Muhammad Angga Pratama

•

•

•

•

•

•

MUHAMMAD MULIA JAYA KUSUMA

•

Riski Arnando

•

Sheren

Published June 3, 2025 © GPL3+

Keypad-Based Precision Servo Motor Angle Controller

Control servo angles with high precision using just a keypad—simple, accurate, and powerful!

IntermediateFull instructions provided12 hours192

Keypad-Based Precision Servo Motor Angle Controller

Things used in this project

Hardware components

STM32F401CB

SG90 Micro-servo motor

Adafruit RGB Backlight LCD - 16x2

Seeed Studio Grove - 12-Channel Capacitive Touch Keypad (ATtiny1616)

Rotary potentiometer (generic)

Software apps and online services

PROTEUS

KEIL uVISION

Story

The servo motor is one of the key components in many electronics projects, especially those that require precise movement, such as robotic arms or simple mechanical systems. However, in practice, adjusting the servo angle is often done using a potentiometer or software connected to a comput. this methods that are less practical for direct, on-site use. This led us to the idea of creating a tool that allows users to set the servo angle directly using a keypad for input and an LCD to display the entered angle.

We developed this project as a way to explore simple input systems that can operate independently without relying on a computer. By using only a microcontroller, a keypad, and an LCD, users can simply enter the desired angle, and the servo will move accordingly. This process not only simplifies usage but also offers an engaging learning experience about how to handle digital input and convert it into precise mechanical motion.

Compared to other, more complex projects, this one offers high practical value. It is not only suitable for experimentation but can also be applied directly in various real-world scenarios. While it may seem simple, this approach provides a strong foundation for understanding the interaction between input, processing, and actuation in electronic systems.

Short description of program code

1. Initialization and basic configuration

This program is intended for the STM32F401, utilizing register and standard C libraries such as stm32f401xc.h and string.h to control the device. The LCD and servo pins are configured at the beginning, and the servo angle input is stored in a buffer. The delay_ms() function provides delays using SysTick, while SystemClock_Config() sets the system clock via the PLL for faster and more stable performance.

2. Initialization GPIO

The GPIO_Init() function enables the clock for GPIOA and GPIOB ports, then configures the GPIOA pins for LCD communication and servo control. The configuration includes output mode, push-pull type, high speed, and alternate function settings for the servo pin. GPIOB is also configured for additional input/output purposes, including mode selection, pull-up/pull-down settings, and high speed. This entire initialization ensures that the pins operate according to their roles for the LCD, servo, and other communication tasks.

3. LCD function

This program controls a 16x2 LCD in 4-bit mode using a microcontroller and direct access to GPIO registers. The lcd_pulse() function sends a signal to the LCD's EN pin, while lcd_nibble() transmits 4-bit data to the LCD. The lcd_send() function sends 8-bit data by splitting it into two nibbles. lcd_init() initializes the LCD, lcd_clear() clears the display, lcd_set_cursor() sets the cursor position, and lcd_puts() displays text. These functions enable the microcontroller to efficiently display data on the LCD.

4. Servo control function

This code snippet is used to control the rotation angle of a servo motor using PWM from the TIM1 timer on the microcontroller. The set_servo_angle() function takes an angle value between 0–180 degrees and converts it into a corresponding compare register value (ccr_value) that matches the PWM pulse, then sets the CCR1 register to adjust the servo position. The TIM1_Init() function initializes the TIM1 timer to generate a PWM signal with a 20 ms period (50 Hz frequency), configures the PWM mode, and enables output on channel 1. After initialization, the servo is set to an initial angle of 0 degrees.

5. keypad function

This code snippet is used to read input from a 4x3 keypad. The keypad_map matrix contains the arrangement of characters according to the button positions on the keypad. The scan_keypad() function scans each column one by one by setting it to a low logic level and reading the rows to detect a pressed key. If a key press is detected, the function returns the corresponding character from the keypad_map; if no key is pressed, it returns zero (0).

6. main function

This code sets up a keypad input system and servo angle control using the STM32. When a button is pressed, the scan_keypad() function detects the character from the 4x4 keypad and displays it on the LCD. If the ‘*’ button is pressed, the user is prompted to enter an angle, and if the ‘#’ button is pressed, the entered value is converted into an angle and the servo is adjusted accordingly. The set_servo_angle() function converts the angle value into a PWM signal using the TIM1 timer, which has been configured to match the servo signal period.

Code

Keypad-Based Precision Servo Motor Angle Controller Program

#include "stm32f401xc.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#define LCD_RS_PIN 0
#define LCD_EN_PIN 1
#define LCD_D4_PIN 2
#define LCD_D5_PIN 3
#define LCD_D6_PIN 4
#define LCD_D7_PIN 5

#define SERVO_PIN 8

char input_buffer[4] = {0};
uint8_t input_idx = 0;
int current_servo_angle = 0;

static void delay_ms(uint32_t ms) {
    SysTick->LOAD = (84000 * ms) - 1;
    SysTick->VAL = 0;
    SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_ENABLE_Msk;
    while(!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk));
    SysTick->CTRL = 0;
}

static void SystemClock_Config(void) {
    RCC->CR |= RCC_CR_HSION;
    while(!(RCC->CR & RCC_CR_HSIRDY));

    RCC->PLLCFGR = (16U<<RCC_PLLCFGR_PLLM_Pos) | (168U<<RCC_PLLCFGR_PLLN_Pos) |
                   (0U<<RCC_PLLCFGR_PLLP_Pos) | RCC_PLLCFGR_PLLSRC_HSI | (7U<<RCC_PLLCFGR_PLLQ_Pos);

    RCC->CR |= RCC_CR_PLLON;
    while(!(RCC->CR & RCC_CR_PLLRDY));

    FLASH->ACR = FLASH_ACR_ICEN | FLASH_ACR_DCEN | FLASH_ACR_PRFTEN | FLASH_ACR_LATENCY_2WS;

    RCC->CFGR |= RCC_CFGR_SW_PLL;
    while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);
}

static void GPIO_Init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN | RCC_AHB1ENR_GPIOBEN;

    GPIOA->MODER &= ~(0xFFF);
    GPIOA->MODER |= (0x1 << (LCD_RS_PIN * 2)) | (0x1 << (LCD_EN_PIN * 2)) |
                    (0x1 << (LCD_D4_PIN * 2)) | (0x1 << (LCD_D5_PIN * 2)) |
                    (0x1 << (LCD_D6_PIN * 2)) | (0x1 << (LCD_D7_PIN * 2));
    GPIOA->OTYPER &= ~(0x3F);
    GPIOA->OSPEEDR |= 0xFFF;

    GPIOA->MODER &= ~(0x3 << (SERVO_PIN * 2));
    GPIOA->MODER |= (0x2 << (SERVO_PIN * 2));

    GPIOA->AFR[1] = (GPIOA->AFR[1] & ~(0xF << ((SERVO_PIN - 8) * 4))) | (0x1 << ((SERVO_PIN - 8) * 4));

    GPIOB->MODER &= ~(0xFF);
    GPIOB->PUPDR = (GPIOB->PUPDR & ~0xFF) | (0x1 << (0 * 2)) | (0x1 << (1 * 2)) |
                   (0x1 << (2 * 2)) | (0x1 << (3 * 2));

    GPIOB->MODER &= ~(0xFF << (4 * 2));
    GPIOB->MODER |= (0x1 << (4 * 2)) | (0x1 << (5 * 2)) | (0x1 << (6 * 2)) | (0x1 << (7 * 2));
    GPIOB->OTYPER &= ~(0xF << 4);
    GPIOB->OSPEEDR |= (0xFF << (4 * 2));
}

static void lcd_pulse(void) {
    GPIOA->BSRR = (1U << (LCD_EN_PIN + 16));
    delay_ms(1);
    GPIOA->BSRR = (1U << LCD_EN_PIN);
    delay_ms(1);
    GPIOA->BSRR = (1U << (LCD_EN_PIN + 16));
    delay_ms(2);
}

static void lcd_nibble(uint8_t n) {
    GPIOA->ODR = (GPIOA->ODR & ~0x3C) | ((n & 0xF) << LCD_D4_PIN);
    lcd_pulse();
}

static void lcd_send(uint8_t v, uint8_t rs) {
    if(rs) GPIOA->BSRR = (1U << LCD_RS_PIN);
    else   GPIOA->BSRR = (1U << (LCD_RS_PIN + 16));

    lcd_nibble(v >> 4);
    lcd_nibble(v & 0xF);
}

static void lcd_init(void) {
    delay_ms(40);
    lcd_nibble(0x3); delay_ms(5);
    lcd_nibble(0x3); delay_ms(1);
    lcd_nibble(0x3);
    lcd_nibble(0x2);
    lcd_send(0x28, 0);
    lcd_send(0x08, 0);
    lcd_send(0x01, 0);
    delay_ms(2);
    lcd_send(0x06, 0);
    lcd_send(0x0C, 0);
}

static void lcd_clear(void) {
    lcd_send(0x01, 0);
    delay_ms(2);
}

static void lcd_set_cursor(uint8_t col, uint8_t row) {
    uint8_t address;
    if (row == 0) {
        address = 0x00 + col;
    } else {
        address = 0x40 + col;
    }
    lcd_send(0x80 | address, 0);
}

static void lcd_puts(const char *s) {
    while(*s) {
        lcd_send(*s++, 1);
    }
}

static void set_servo_angle(int angle) {
    if (angle < 0) angle = 0;
    if (angle > 180) angle = 180;

    current_servo_angle = angle;

    uint32_t ccr_value = 1000 + ((angle * 1000 + 90)/180);

    TIM1->CCR1 = ccr_value;
    TIM1->EGR |= TIM_EGR_UG;
}

static void TIM1_Init(void) {
    RCC->APB2ENR |= RCC_APB2ENR_TIM1EN;

    TIM1->PSC = 84 - 1;

    TIM1->ARR = 20000 - 1;

    TIM1->CCMR1 = (6U<<TIM_CCMR1_OC1M_Pos) | TIM_CCMR1_OC1PE;

    TIM1->CCER |= TIM_CCER_CC1E;

    TIM1->BDTR |= TIM_BDTR_MOE;

    TIM1->CR1 |= TIM_CR1_ARPE;

    TIM1->EGR |= TIM_EGR_UG;

    TIM1->CR1 |= TIM_CR1_CEN;

    set_servo_angle(0);
}

static const char keypad_map[4][3] = {
    {'7','8','9',},
    {'4','5','6',},
    {'1','2','3',},
    {'*','0','#',}
};

static char scan_keypad(void) {
    for(uint8_t c=0; c<4; c++){
        GPIOB->BSRR = (0xF << 4);
        GPIOB->BSRR = ((1U << (4 + c)) << 16);

        delay_ms(1);

        uint8_t r = GPIOB->IDR & 0xF;

        for(uint8_t i=0; i<4; i++) {
            if(!(r & (1U << i))) {
                delay_ms(5);
                if(!( (GPIOB->IDR & 0xF) & (1U << i) )) {
                    return keypad_map[i][c];
                }
            }
        }
    }
    return 0;
}

int main(void) {
    SystemClock_Config();
    GPIO_Init();
    lcd_init();
    TIM1_Init();

    char last_key = 0;
    char lcd_display_buffer[17];

    lcd_clear();
    lcd_set_cursor(0, 0);
    lcd_puts("Enter Angle:");
    lcd_set_cursor(0, 1);
    sprintf(lcd_display_buffer, "Current: %d deg", current_servo_angle);
    lcd_puts(lcd_display_buffer);

    while(1) {
        char key = scan_keypad();

        if (key && key != last_key) {
            if (key >= '0' && key <= '9') {
                if (input_idx < 3) {
                    input_buffer[input_idx++] = key;
                    input_buffer[input_idx] = '\0';

                    lcd_set_cursor(12, 0);
                    lcd_puts(input_buffer);
                    for(int i = input_idx; i < 3; i++) {
                        lcd_send(' ', 1);
                    }
                }
            } else if (key == '#') {
                if (input_idx > 0) {
                    int new_angle = atoi(input_buffer);
                    set_servo_angle(new_angle);

                    lcd_clear();
                    lcd_set_cursor(0, 0);
                    lcd_puts("Angle Set!");
                    lcd_set_cursor(0, 1);
                    sprintf(lcd_display_buffer, "Current: %d deg", new_angle);
                    lcd_puts(lcd_display_buffer);

                    input_idx = 0;
                    input_buffer[0] = '\0';
                }
            } else if (key == '*') {
                input_idx = 0;
                input_buffer[0] = '\0';
                lcd_clear();
                lcd_set_cursor(0, 0);
                lcd_puts("Enter Angle:");
                lcd_set_cursor(12, 0);
                lcd_puts("   ");
                lcd_set_cursor(0, 1);
                sprintf(lcd_display_buffer, "Current: %d deg", current_servo_angle);
                lcd_puts(lcd_display_buffer);
            }
        }
        last_key = key;
    }
}

Keypad-Based Precision Servo Motor Angle Controller

Things used in this project

Hardware components

Software apps and online services

Story

Schematics