Timers, PWM, and Input Capture

Up-counting:    0 -> 1 -> 2 -> ... -> ARR -> 0 -> 1 -> ...
Down-counting:  ARR -> ARR-1 -> ... -> 0 -> ARR -> ARR-1 -> ...
Center-aligned: 0 -> 1 -> ... -> ARR -> ARR-1 -> ... -> 0 -> 1 -> ...

  Servo PWM signal:

  |<----------- 20 ms (50 Hz) ---------->|

  0 deg:     ___                           ___
            |   |                         |   |
  __________| 0.5ms |_____________________| 0.5ms
            |<->|

  90 deg:    ______                        ___
            |      |                      |
  __________| 1.5ms  |___________________| 1.5
            |<---->|

  180 deg:   _________                     ___
            |         |                   |
  __________| 2.5ms     |________________| 2.5
            |<------->|

void servo_pwm_init(void) {
    /* Enable clocks for GPIOA and TIM2 */
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
    RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;

    /* PA0 as alternate function push-pull, 50 MHz */
    GPIOA->CRL &= ~(0xF << 0);
    GPIOA->CRL |=  (0xB << 0);

    /*
     * Timer clock = 72 MHz
     * PSC = 72 - 1 = 71   -> counter clock = 1 MHz (1 us per tick)
     * ARR = 20000 - 1      -> period = 20 ms (50 Hz)
     *
     * CCR1 = 500   -> 0.5 ms pulse -> 0 degrees
     * CCR1 = 1500  -> 1.5 ms pulse -> 90 degrees
     * CCR1 = 2500  -> 2.5 ms pulse -> 180 degrees
     */
    TIM2->PSC = 72 - 1;
    TIM2->ARR = 20000 - 1;
    TIM2->CCR1 = 1500;         /* Start at center (90 degrees) */

    /* PWM mode 1 on channel 1, preload enable */
    TIM2->CCMR1 &= ~TIM_CCMR1_OC1M;
    TIM2->CCMR1 |= (0x6 << 4);   /* PWM mode 1 */
    TIM2->CCMR1 |= TIM_CCMR1_OC1PE;  /* Preload enable */

    TIM2->CCER |= TIM_CCER_CC1E;  /* Enable channel 1 output */
    TIM2->CR1 |= TIM_CR1_ARPE;    /* Auto-reload preload */
    TIM2->EGR |= TIM_EGR_UG;      /* Force update to load preload values */
    TIM2->CR1 |= TIM_CR1_CEN;     /* Start timer */
}

void servo_set_angle(uint16_t angle_degrees) {
    if (angle_degrees > 180) angle_degrees = 180;

    /* Map 0-180 degrees to 500-2500 us pulse width */
    uint16_t pulse_us = 500 + (angle_degrees * 2000) / 180;
    TIM2->CCR1 = pulse_us;
}

  Hardware encoder mode (TIM3):

  PA6 (TIM3_CH1) ----> TI1 input
  PA7 (TIM3_CH2) ----> TI2 input

  +--------+     +---------------+
  |Encoder |     |     TIM3      |
  | CLK ---+---->| TI1  Encoder  |
  | DT  ---+---->| TI2  logic    |
  +--------+     |       |       |
                 |   +---+---+   |
                 |   | CNT   |   |
                 |   | (auto |   |
                 |   | inc/  |   |
                 |   | dec)  |   |
                 |   +-------+   |
                 +---------------+

  CPU reads TIM3->CNT for position.
  Zero CPU overhead during counting.

void encoder_hw_init(void) {
    /* Enable clocks for GPIOA and TIM3 */
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
    RCC->APB1ENR |= RCC_APB1ENR_TIM3EN;

    /* PA6 (TIM3_CH1) and PA7 (TIM3_CH2) as input floating */
    GPIOA->CRL &= ~((0xF << 24) | (0xF << 28));
    GPIOA->CRL |=  ((0x4 << 24) | (0x4 << 28));

    /*
     * Encoder mode 3: count on both TI1 and TI2 edges
     * This gives 4x resolution (4 counts per detent on KY-040)
     *
     * SMS = 011 (encoder mode 3)
     * CC1S = 01 (IC1 mapped to TI1)
     * CC2S = 01 (IC2 mapped to TI2)
     */
    TIM3->SMCR &= ~TIM_SMCR_SMS;
    TIM3->SMCR |= TIM_SMCR_SMS_0 | TIM_SMCR_SMS_1;  /* Encoder mode 3 */

    TIM3->CCMR1 &= ~(TIM_CCMR1_CC1S | TIM_CCMR1_CC2S);
    TIM3->CCMR1 |= TIM_CCMR1_CC1S_0 | TIM_CCMR1_CC2S_0;

    /* Input filter: 4 samples at fDTS/2 (debouncing) */
    TIM3->CCMR1 |= (0x3 << 4) | (0x3 << 12);

    /* Set auto-reload to maximum for free-running counter */
    TIM3->ARR = 0xFFFF;

    /* Start at midpoint so we can detect both directions */
    TIM3->CNT = 32768;

    /* Enable the timer */
    TIM3->CR1 |= TIM_CR1_CEN;
}

int16_t encoder_hw_read(void) {
    return (int16_t)(TIM3->CNT - 32768);
}

  Input capture for period measurement:

  Signal: _____       _________       ____
               |     |         |     |
               |_____|         |_____|
                ^                ^
           capture1          capture2
           (CNT=1000)        (CNT=6000)

  Period = capture2 - capture1
         = 6000 - 1000 = 5000 ticks
  At 1 MHz timer clock: 5000 us = 5 ms
  Frequency = 1 / 0.005 = 200 Hz

volatile uint32_t capture_value = 0;
volatile uint32_t last_capture = 0;
volatile uint32_t period_ticks = 0;

void input_capture_init(void) {
    /* TIM4 CH1 on PB6 as input capture */
    RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
    RCC->APB1ENR |= RCC_APB1ENR_TIM4EN;

    /* PB6 as input floating */
    GPIOB->CRL &= ~(0xF << 24);
    GPIOB->CRL |=  (0x4 << 24);

    /* TIM4 prescaler: 72 MHz / 72 = 1 MHz (1 us resolution) */
    TIM4->PSC = 72 - 1;
    TIM4->ARR = 0xFFFF;

    /* CC1 as input, mapped to TI1, rising edge, no filter */
    TIM4->CCMR1 &= ~TIM_CCMR1_CC1S;
    TIM4->CCMR1 |= TIM_CCMR1_CC1S_0;    /* IC1 mapped to TI1 */

    TIM4->CCER &= ~TIM_CCER_CC1P;        /* Rising edge */
    TIM4->CCER |= TIM_CCER_CC1E;         /* Enable capture */

    /* Enable capture interrupt */
    TIM4->DIER |= TIM_DIER_CC1IE;
    NVIC_EnableIRQ(TIM4_IRQn);

    TIM4->CR1 |= TIM_CR1_CEN;
}

void TIM4_IRQHandler(void) {
    if (TIM4->SR & TIM_SR_CC1IF) {
        TIM4->SR &= ~TIM_SR_CC1IF;

        capture_value = TIM4->CCR1;
        period_ticks = capture_value - last_capture;
        last_capture = capture_value;
    }
}

#include "stm32f103xb.h"
#include <string.h>

/* Forward declarations (implementations from above) */
void clock_init(void);
void systick_init(void);
void uart_init(void);
void uart_send_string(const char *str);
void servo_pwm_init(void);
void servo_set_angle(uint16_t angle);
void encoder_hw_init(void);
int16_t encoder_hw_read(void);

/* Simple integer-to-string conversion */
void itoa_simple(int32_t val, char *buf) {
    if (val < 0) { *buf++ = '-'; val = -val; }
    char tmp[12];
    int i = 0;
    do { tmp[i++] = '0' + (val % 10); val /= 10; } while (val);
    while (i > 0) *buf++ = tmp[--i];
    *buf = '\0';
}

int main(void) {
    clock_init();
    systick_init();
    uart_init();
    servo_pwm_init();
    encoder_hw_init();

    /* PB5 as input pull-up for encoder button */
    RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
    GPIOB->CRL &= ~(0xF << 20);
    GPIOB->CRL |=  (0x8 << 20);
    GPIOB->ODR |=  (1 << 5);

    int16_t last_encoder = 0;
    uint16_t servo_angle = 90;  /* Start centered */
    char buf[32];

    uart_send_string("Servo Pan Controller Ready\r\n");
    uart_send_string("Rotate encoder to pan, press to center.\r\n\r\n");

    while (1) {
        int16_t enc_pos = encoder_hw_read();
        int16_t delta = enc_pos - last_encoder;

        if (delta != 0) {
            last_encoder = enc_pos;

            /* Each encoder step moves servo by 2 degrees */
            int16_t new_angle = (int16_t)servo_angle + (delta * 2);
            if (new_angle < 0) new_angle = 0;
            if (new_angle > 180) new_angle = 180;
            servo_angle = (uint16_t)new_angle;

            servo_set_angle(servo_angle);

            /* Print status */
            uart_send_string("Angle: ");
            itoa_simple(servo_angle, buf);
            uart_send_string(buf);
            uart_send_string(" deg  |  Pulse: ");
            itoa_simple(500 + (servo_angle * 2000) / 180, buf);
            uart_send_string(buf);
            uart_send_string(" us  |  Encoder: ");
            itoa_simple(enc_pos, buf);
            uart_send_string(buf);
            uart_send_string("\r\n");
        }

        /* Button press: return to center */
        if (!(GPIOB->IDR & (1 << 5))) {
            servo_angle = 90;
            servo_set_angle(90);
            uart_send_string(">> Centered at 90 degrees\r\n");
            /* Simple debounce delay */
            for (volatile uint32_t i = 0; i < 200000; i++);
        }
    }
}