STM32 ile Canon EF
Lens Kontrolü.

PLL Source  : HSI (16 MHz)
PLL/M       : 1   → 16 MHz
PLL/N       : ×10 → 160 MHz
PLL/R       : /2  → 80 MHz
SYSCLK      : 80 MHz
AHB Prescaler  : /1 → HCLK  = 80 MHz
APB1 Prescaler : /1 → PCLK1 = 80 MHz  ← SPI1 buradan beslenecek
APB2 Prescaler : /1 → PCLK2 = 80 MHz

static void MX_SPI1_Init(void)
{
    hspi1.Instance               = SPI1;
    hspi1.Init.Mode              = SPI_MODE_MASTER;
    hspi1.Init.Direction         = SPI_DIRECTION_2LINES;   /* full-duplex */
    hspi1.Init.DataSize          = SPI_DATASIZE_8BIT;
    hspi1.Init.CLKPolarity       = SPI_POLARITY_HIGH;      /* CPOL = 1 */
    hspi1.Init.CLKPhase          = SPI_PHASE_2EDGE;        /* CPHA = 1 → Mode 3 */
    hspi1.Init.NSS               = SPI_NSS_SOFT;           /* CS yok */
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_1024; /* 78.125 kHz */
    hspi1.Init.FirstBit          = SPI_FIRSTBIT_MSB;
    hspi1.Init.TIMode            = SPI_TIMODE_DISABLE;
    hspi1.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
    HAL_SPI_Init(&hspi1);
}

#ifndef EF_LENS_H
#define EF_LENS_H

#include "main.h"
#include <stdint.h>
#include <stdbool.h>

/* ── Komut byte'ları ──────────────────────────────────────────── */
#define EF_CMD_INIT          0x0A
#define EF_CMD_STATUS        0x0D
#define EF_CMD_FOCUS_MOVE    0x44
#define EF_CMD_FOCUS_STOP    0x06
#define EF_CMD_FOCUS_INF     0xA0
#define EF_CMD_FOCUS_NEAR    0xB0
#define EF_CMD_APERTURE      0x13
#define EF_CMD_APERTURE_OPEN 0x72

/* ── Focus yön sabitleri ──────────────────────────────────────── */
#define EF_DIR_NEAR  0x00
#define EF_DIR_FAR   0x01

/* ── Lens bilgi yapısı ────────────────────────────────────────── */
typedef struct {
    uint8_t  lens_id;
    uint8_t  type_flags;
    float    aperture_max;     /* f-stop, ör. 1.4 */
    float    aperture_min;     /* f-stop, ör. 22.6 */
    uint16_t focal_length_mm;
    bool     has_usm;
    bool     has_is;
    uint8_t  raw[16];          /* ham INIT yanıtı */
} ef_lens_info_t;

/* ── API ──────────────────────────────────────────────────────── */
HAL_StatusTypeDef ef_init(SPI_HandleTypeDef *hspi);
HAL_StatusTypeDef ef_get_info(ef_lens_info_t *out);
HAL_StatusTypeDef ef_focus_move(uint8_t dir, uint8_t speed, uint16_t steps);
HAL_StatusTypeDef ef_focus_stop(void);
HAL_StatusTypeDef ef_focus_inf(void);
HAL_StatusTypeDef ef_focus_near(void);
HAL_StatusTypeDef ef_aperture_set(float fstop);
HAL_StatusTypeDef ef_aperture_open(void);
HAL_StatusTypeDef ef_status_read(uint8_t *buf, uint8_t len);

#endif

#include "ef_lens.h"
#include <math.h>
#include <string.h>

static SPI_HandleTypeDef *_spi;

/* ── µs gecikmesi (DWT cycle counter) ────────────────────────── */
static void dwt_enable(void)
{
    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
    DWT->CYCCNT = 0;
    DWT->CTRL  |= DWT_CTRL_CYCCNTENA_Msk;
}

static void delay_us(uint32_t us)
{
    uint32_t start = DWT->CYCCNT;
    uint32_t ticks = us * (SystemCoreClock / 1000000UL);
    while ((DWT->CYCCNT - start) < ticks);
}

/*
 * ef_send — tek byte gönder, dummy byte al (yanıt yok sayılır)
 * ef_recv — dummy byte gönder (Dclk üret), yanıt byte'ı al
 */
static HAL_StatusTypeDef ef_send(uint8_t b)
{
    uint8_t dummy;
    return HAL_SPI_TransmitReceive(_spi, &b, &dummy, 1, 10);
}

static HAL_StatusTypeDef ef_recv(uint8_t *b)
{
    uint8_t zero = 0x00;
    return HAL_SPI_TransmitReceive(_spi, &zero, b, 1, 10);
}

/*
 * ef_cmd — genel transaction:
 *   komut gönder → parametre gönder → yanıt al
 *   Her byte arasına 5 µs, komut/yanıt arasına 20 µs eklenir.
 */
static HAL_StatusTypeDef ef_cmd(uint8_t cmd,
                                   const uint8_t *params, uint8_t plen,
                                   uint8_t *rx,          uint8_t rlen)
{
    HAL_StatusTypeDef ret;

    ret = ef_send(cmd);
    if (ret != HAL_OK) return ret;

    for (uint8_t i = 0; i < plen; i++) {
        delay_us(5);
        ret = ef_send(params[i]);
        if (ret != HAL_OK) return ret;
    }

    delay_us(20);

    for (uint8_t i = 0; i < rlen; i++) {
        ret = ef_recv(&rx[i]);
        if (ret != HAL_OK) return ret;
        delay_us(5);
    }

    HAL_Delay(1);  /* transaction bitiş boşluğu */
    return HAL_OK;
}

HAL_StatusTypeDef ef_init(SPI_HandleTypeDef *hspi)
{
    _spi = hspi;
    dwt_enable();

    /*
     * Lens güç aldıktan sonra MCU'sunun boot etmesi için bekle.
     * USM serisi ~500 ms, STM serisi ~200 ms.
     * 600 ms tüm EF/EF-S lenslerde güvenlidir.
     */
    HAL_Delay(600);

    uint8_t rx[8];
    return ef_cmd(EF_CMD_INIT, NULL, 0, rx, 8);
}

HAL_StatusTypeDef ef_get_info(ef_lens_info_t *out)
{
    uint8_t rx[16] = {0};
    HAL_StatusTypeDef ret = ef_cmd(EF_CMD_INIT, NULL, 0, rx, 16);
    if (ret != HAL_OK) return ret;

    memcpy(out->raw, rx, 16);
    out->type_flags      = rx[0];
    out->lens_id         = rx[1];
    out->focal_length_mm = (uint16_t)rx[4] | ((uint16_t)rx[5] << 8);
    out->has_usm         = (rx[0] & 0x02) != 0;
    out->has_is          = (rx[0] & 0x04) != 0;

    /* Av × 8 → f-stop: fstop = 2^(Av/2) */
    out->aperture_max = powf(2.0f, (rx[2] / 8.0f) / 2.0f);
    out->aperture_min = powf(2.0f, (rx[3] / 8.0f) / 2.0f);

    return HAL_OK;
}

HAL_StatusTypeDef ef_focus_move(uint8_t dir, uint8_t speed, uint16_t steps)
{
    uint8_t p[4] = { dir, speed,
                     (uint8_t)(steps >> 8),
                     (uint8_t)(steps & 0xFF) };
    uint8_t rx[1];
    return ef_cmd(EF_CMD_FOCUS_MOVE, p, 4, rx, 1);
}

HAL_StatusTypeDef ef_focus_stop(void)
{
    uint8_t rx[1];
    return ef_cmd(EF_CMD_FOCUS_STOP, NULL, 0, rx, 1);
}

HAL_StatusTypeDef ef_focus_inf(void)
{
    uint8_t rx[1];
    return ef_cmd(EF_CMD_FOCUS_INF, NULL, 0, rx, 1);
}

HAL_StatusTypeDef ef_focus_near(void)
{
    uint8_t rx[1];
    return ef_cmd(EF_CMD_FOCUS_NEAR, NULL, 0, rx, 1);
}

HAL_StatusTypeDef ef_aperture_set(float fstop)
{
    /*
     * f-stop → Av → wire byte:
     *   Av   = 2 × log2(fstop)
     *   wire = round(Av × 8)
     *
     *   f/1.4 → wire = 8
     *   f/5.6 → wire = 40
     *   f/16  → wire = 64
     */
    float   av   = 2.0f * (logf(fstop) / logf(2.0f));
    uint8_t wire = (uint8_t)(av * 8.0f + 0.5f);

    uint8_t p[1] = { wire };
    uint8_t rx[1];
    HAL_StatusTypeDef ret = ef_cmd(EF_CMD_APERTURE, p, 1, rx, 1);
    if (ret != HAL_OK) return ret;

    HAL_Delay(80);  /* diyafram bıçakları kapanana kadar bekle */
    return HAL_OK;
}

HAL_StatusTypeDef ef_aperture_open(void)
{
    uint8_t rx[1];
    return ef_cmd(EF_CMD_APERTURE_OPEN, NULL, 0, rx, 1);
}

HAL_StatusTypeDef ef_status_read(uint8_t *buf, uint8_t len)
{
    if (len > 32) len = 32;
    return ef_cmd(EF_CMD_STATUS, NULL, 0, buf, len);
}

/* Bu fonksiyon syscalls.c içine veya doğrudan main.c'ye yazılabilir */
int __io_putchar(int ch)
{
    HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, 10);
    return ch;
}

static void uprint(const char *s)
{
    HAL_UART_Transmit(&huart2, (const uint8_t *)s, strlen(s), 200);
}

static char    rx_buf[64];
static uint8_t rx_idx = 0;

static void process_cmd(char *line)
{
    char *tok = strtok(line, " \r\n");
    if (!tok) return;

    if (strcmp(tok, "?") == 0 || strcmp(tok, "h") == 0) {
        uprint("\r\n--- Canon EF Lens Kontrolu ---\r\n");
        uprint("info          : Lens bilgisi\r\n");
        uprint("fi            : Focus sonsuza\r\n");
        uprint("fn            : Focus minimuma\r\n");
        uprint("f+ <n> [hiz] : N adim uzaga (hiz 1-4)\r\n");
        uprint("f- <n> [hiz] : N adim yakina\r\n");
        uprint("fs            : Motoru durdur\r\n");
        uprint("a <fstop>    : Diyafram ayarla (a 5.6)\r\n");
        uprint("ao            : Diyafram tam ac\r\n");
        uprint("st [n]        : Ham durum (n byte)\r\n");
        uprint("------------------------------\r\n");

    } else if (strcmp(tok, "info") == 0) {
        ef_lens_info_t info = {0};
        if (ef_get_info(&info) == HAL_OK) {
            printf("Lens ID   : 0x%02X\r\n",  info.lens_id);
            printf("Focal len : %d mm\r\n",    info.focal_length_mm);
            printf("Diyafram  : f/%.1f - f/%.1f\r\n",
                   info.aperture_max, info.aperture_min);
            printf("USM: %s  IS: %s\r\n",
                   info.has_usm ? "EVET" : "HAYIR",
                   info.has_is  ? "EVET" : "HAYIR");
            uprint("Ham yanit : ");
            for (int i = 0; i < 8; i++)
                printf("%02X ", info.raw[i]);
            uprint("\r\n");
        } else {
            uprint("HATA: lens yanit vermedi\r\n");
        }

    } else if (strcmp(tok, "fi") == 0) {
        ef_focus_inf();
        uprint("Focus → sonsuz\r\n");

    } else if (strcmp(tok, "fn") == 0) {
        ef_focus_near();
        uprint("Focus → minimum\r\n");

    } else if (strcmp(tok, "f+") == 0) {
        char *ns = strtok(NULL, " ");
        char *ss = strtok(NULL, " ");
        uint16_t steps = ns ? (uint16_t)atoi(ns) : 100;
        uint8_t  speed = ss ? (uint8_t)atoi(ss)  : 2;
        ef_focus_move(EF_DIR_FAR, speed, steps);
        printf("FAR %u adim hiz=%u\r\n", steps, speed);

    } else if (strcmp(tok, "f-") == 0) {
        char *ns = strtok(NULL, " ");
        char *ss = strtok(NULL, " ");
        uint16_t steps = ns ? (uint16_t)atoi(ns) : 100;
        uint8_t  speed = ss ? (uint8_t)atoi(ss)  : 2;
        ef_focus_move(EF_DIR_NEAR, speed, steps);
        printf("NEAR %u adim hiz=%u\r\n", steps, speed);

    } else if (strcmp(tok, "fs") == 0) {
        ef_focus_stop();
        uprint("STOP\r\n");

    } else if (strcmp(tok, "a") == 0) {
        char *fs = strtok(NULL, " ");
        if (!fs) { uprint("Kullanim: a <fstop>\r\n"); return; }
        float fstop = strtof(fs, NULL);
        if (fstop < 1.0f || fstop > 32.0f) {
            uprint("Gecersiz fstop\r\n"); return;
        }
        ef_aperture_set(fstop);
        printf("Diyafram f/%.1f\r\n", fstop);

    } else if (strcmp(tok, "ao") == 0) {
        ef_aperture_open();
        uprint("Diyafram tam acik\r\n");

    } else if (strcmp(tok, "st") == 0) {
        char *ns = strtok(NULL, " ");
        uint8_t n   = ns ? (uint8_t)atoi(ns) : 4;
        uint8_t buf[32] = {0};
        if (ef_status_read(buf, n) == HAL_OK) {
            printf("Status: ");
            for (uint8_t i = 0; i < n; i++)
                printf("%02X ", buf[i]);
            uprint("\r\n");
        } else {
            uprint("HATA\r\n");
        }

    } else {
        printf("? → %s\r\n", tok);
    }

    uprint("> ");
}

void app_main(void)
{
    uprint("\r\nCanon EF / NUCLEO-L432KC\r\n");
    uprint("SPI1 78kHz Mode3 | USART2 115200\r\n");

    if (ef_init(&hspi1) == HAL_OK)
        uprint("Lens HAZIR. '?' yaz.\r\n> ");
    else
        uprint("Lens yanit vermedi. Baglanti kontrol et.\r\n> ");

    uint8_t ch;
    while (1) {
        if (HAL_UART_Receive(&huart2, &ch, 1, 1) == HAL_OK) {
            HAL_UART_Transmit(&huart2, &ch, 1, 5);
            if (ch == '\r' || ch == '\n') {
                rx_buf[rx_idx] = '\0';
                uprint("\r\n");
                if (rx_idx > 0) process_cmd(rx_buf);
                rx_idx = 0;
            } else if (ch == 0x7F && rx_idx > 0) {
                rx_idx--;
            } else if (rx_idx < sizeof(rx_buf) - 1) {
                rx_buf[rx_idx++] = ch;
            }
        }
    }
}

Canon EF / NUCLEO-L432KC
SPI1 78kHz Mode3 | USART2 115200
Lens HAZIR. '?' yaz.
> info
Lens ID   : 0xEB
Focal len : 50 mm
Diyafram  : f/1.4 - f/22.6
USM: EVET  IS: HAYIR
Ham yanit : 02 EB 08 60 32 00 00 00

> ao
Diyafram tam acik

> a 5.6
Diyafram f/5.6

> fi
Focus → sonsuz

> f- 300 2
NEAR 300 adim hiz=2

> f- 300 2
NEAR 300 adim hiz=2

> st
Status: 00 05 7B 00

> fn
Focus → minimum