🔌 hal::usb

USB 2.0 Full Speed - Device/Host/OTG Controller

~420 satır ~25 fonksiyon STM32F4/F7/H7

📖 Genel Bakış

USB modülü, USB 2.0 Full Speed (12 Mbps) iletişimi sağlar. CDC (Virtual COM), HID (Keyboard/Mouse), MSC (Mass Storage) device classları ile PC bağlantısı kurar. Host mode ile USB flash disk, keyboard okuma yapılabilir. IoT data logging, debug console, firmware update ve user interface için kritiktir.

🔑 Temel Özellikler

USB 2.0 Full Speed: 12 Mbps (Low Speed 1.5 Mbps de desteklenir)
Device Mode: PC'ye bağlanarak virtual device olur
Host Mode: USB periferalleri bağlanabilir (flash, keyboard)
OTG Support: Device ve Host modları arasında dinamik geçiş
Device Classes: CDC, HID, MSC, Audio, Custom
DMA Support: High-speed data transfer
VBUS Detection: USB cable takılma algılama
Self/Bus Powered: Güç yönetimi esnekliği

🚀 Hızlı Başlangıç

içe_aktar hal::usb, hal::gpio

// USB pins: PA11 (D-), PA12 (D+)
gpio.pin_init(gpio.PORT_A, 11, yap
    mode: gpio.MODE_AF,
    af: gpio.AF10_USB
son)

gpio.pin_init(gpio.PORT_A, 12, yap
    mode: gpio.MODE_AF,
    af: gpio.AF10_USB
son)

// Initialize USB CDC (Virtual COM Port)
usb.init_cdc(yap
    vid: 0x0483,  // ST Microelectronics VID
    pid: 0x5740,  // CDC PID
    manufacturer: "BERK Embedded",
    product: "Virtual COM Port"
son)

// Connect to PC
usb.connect()

// Wait for enumeration
döngü yap
    eğer usb.is_configured() yap
        kır
    son
son

io.yazdir_satır("USB connected!")

// Send data to PC
usb.cdc_write("Hello from BERK!\r\n")

📦 Tipler ve Enum'lar

// USB Mode
enum Mode {
    DEVICE,    // Device mode (slave)
    HOST,      // Host mode (master)
    OTG        // On-The-Go (dynamic)
}

// Device Classes
enum DeviceClass {
    CDC,       // Communication Device Class (Virtual COM)
    HID,       // Human Interface Device (Keyboard/Mouse)
    MSC,       // Mass Storage Class (USB Disk)
    AUDIO,     // Audio Class
    CUSTOM     // Custom class
}

// USB Speed
enum Speed {
    LOW_SPEED,   // 1.5 Mbps
    FULL_SPEED,  // 12 Mbps
    HIGH_SPEED   // 480 Mbps (USB 2.0 HS only)
}

// Power Mode
enum PowerMode {
    SELF_POWERED,   // External power supply
    BUS_POWERED     // Powered from USB cable (max 500 mA)
}

yapı USBConfig yap
    mode: Mode = DEVICE,
    device_class: DeviceClass = CDC,
    speed: Speed = FULL_SPEED,
    power_mode: PowerMode = BUS_POWERED,
    max_power_ma: sayı = 100,
    vid: sayı16 = 0x0483,
    pid: sayı16 = 0x5740
son

💡 Örnek 1: USB CDC Virtual COM Port (Debug Console)

Problem: PC ile seri haberleşme için UART yerine USB kullanmak

içe_aktar hal::usb

değişken usb_rx_buffer: Dizi<sayı8> = Dizi.yeni(256)
değişken usb_rx_index: sayı = 0

fonksiyon usb_console_init() yap
    usb.init_cdc(yap
        vid: 0x0483,
        pid: 0x5740,
        manufacturer: "BERK",
        product: "Debug Console",
        serial_number: "BERK-001"
    son)
    
    // Set receive callback
    usb.cdc_set_rx_callback(usb_console_rx_handler)
    
    usb.connect()
    
    // Wait for enumeration
    döngü yap
        eğer usb.is_configured() yap
            kır
        son
        delay_ms(100)
    son
    
    usb.cdc_write("\r\n=== BERK Embedded Debug Console ===\r\n")
    usb.cdc_write("Type 'help' for commands\r\n> ")
son

fonksiyon usb_console_rx_handler(data: Dizi<sayı8>) yap
    için byte içinde data yap
        eğer byte == 13 yap  // Enter key
            // Process command
            usb.cdc_write("\r\n")
            
            değişken cmd = Metin.from_bytes(usb_rx_buffer, usb_rx_index)
            usb_console_process_command(cmd)
            
            usb_rx_index = 0
            usb.cdc_write("> ")
        yoksa eğer byte == 8 veya byte == 127 yap  // Backspace
            eğer usb_rx_index > 0 yap
                usb_rx_index = usb_rx_index - 1
                usb.cdc_write("\b \b")  // Erase character
            son
        yoksa yap
            eğer usb_rx_index < 256 yap
                usb_rx_buffer[usb_rx_index] = byte
                usb_rx_index = usb_rx_index + 1
                usb.cdc_write_byte(byte)  // Echo
            son
        son
    son
son

fonksiyon usb_console_process_command(cmd: Metin) yap
    eşleştir cmd yap
        "help" => yap
            usb.cdc_write("Commands:\r\n")
            usb.cdc_write("  help    - Show this help\r\n")
            usb.cdc_write("  status  - System status\r\n")
            usb.cdc_write("  reset   - Reset system\r\n")
        son,
        
        "status" => yap
            usb.cdc_write("CPU: STM32F407\r\n")
            usb.cdc_write("Clock: 168 MHz\r\n")
            usb.cdc_write("Uptime: " + systick.get_ms().metne() + " ms\r\n")
        son,
        
        "reset" => yap
            usb.cdc_write("Resetting...\r\n")
            delay_ms(100)
            nvic.system_reset()
        son,
        
        _ => yap
            usb.cdc_write("Unknown command: " + cmd + "\r\n")
        son
    son
son

Kullanım: PC'de PuTTY/TeraTerm ile /dev/ttyACM0 veya COM3 açın. 115200 baud ayarı gereksiz (USB CDC).

💡 Örnek 2: USB HID Keyboard Emulation

Problem: MCU'yu USB klavye gibi göstermek (otomatik yazma)

içe_aktar hal::usb

fonksiyon usb_keyboard_init() yap
    usb.init_hid(yap
        vid: 0x0483,
        pid: 0x5750,
        manufacturer: "BERK",
        product: "USB Keyboard",
        hid_type: usb.HID_KEYBOARD
    son)
    
    usb.connect()
    
    // Wait for enumeration
    döngü yap
        eğer usb.is_configured() yap
            kır
        son
        delay_ms(100)
    son
son

fonksiyon keyboard_press(key: sayı8) yap
    // HID keyboard report: [modifier, reserved, key1-6]
    değişken report: Dizi<sayı8> = [0, 0, key, 0, 0, 0, 0, 0]
    
    // Send key press
    usb.hid_send_report(report)
    
    delay_ms(50)
    
    // Send key release
    report[2] = 0
    usb.hid_send_report(report)
    
    delay_ms(50)
son

fonksiyon keyboard_type_string(text: Metin) yap
    için karakter içinde text yap
        // Convert ASCII to HID keycode
        değişken keycode = ascii_to_hid_keycode(karakter)
        keyboard_press(keycode)
    son
son

fonksiyon ana() yap
    usb_keyboard_init()
    
    io.yazdir_satır("USB Keyboard ready")
    
    // Wait for button press
    döngü yap
        eğer button_pressed() yap
            // Type "Hello World!" on host PC
            keyboard_type_string("Hello World!")
            keyboard_press(0x28)  // Enter key
            
            delay_ms(1000)
        son
    son
son

Sonuç: PC'ye takıldığında gerçek klavye gibi algılanır. Otomatik yazma, macro sistemi.

💡 Örnek 3: USB MSC - Mass Storage (USB Disk Emulation)

Problem: SD card'ı USB flash disk gibi göstermek

içe_aktar hal::usb, hal::sdio

fonksiyon usb_msc_init() yap
    // Initialize SD card
    sdio.init()
    
    // Get SD card info
    değişken sd_info = sdio.get_card_info()
    
    io.yazdir_satır("SD Card: " + (sd_info.capacity / 1024 / 1024).metne() + " MB")
    
    // Initialize USB MSC
    usb.init_msc(yap
        vid: 0x0483,
        pid: 0x5720,
        product: "BERK USB Disk",
        block_count: sd_info.block_count,
        block_size: sd_info.block_size,
        read_callback: msc_read_block,
        write_callback: msc_write_block
    son)
    
    usb.connect()
    
    io.yazdir_satır("USB Mass Storage ready")
son

fonksiyon msc_read_block(block_num: sayı, buffer: Dizi<sayı8>) -> mantık yap
    // Read block from SD card
    dön sdio.read_blocks(block_num, 1, buffer)
son

fonksiyon msc_write_block(block_num: sayı, data: Dizi<sayı8>) -> mantık yap
    // Write block to SD card
    dön sdio.write_blocks(block_num, 1, data)
son

fonksiyon ana() yap
    usb_msc_init()
    
    döngü yap
        // Handle USB events
        usb.poll()
        
        // LED blink when active
        eğer usb.is_active() yap
            led_toggle()
        son
        
        delay_ms(100)
    son
son

Kullanım: PC'ye takıldığında USB flash disk gibi görünür. Dosya kopyalama çalışır.

📚 API Referansı

Temel Fonksiyonlar

// USB Initialization
fonksiyon init_cdc(config: CDCConfig)
fonksiyon init_hid(config: HIDConfig)
fonksiyon init_msc(config: MSCConfig)

// Connection
fonksiyon connect()
fonksiyon disconnect()
fonksiyon is_configured() -> mantık

// CDC Functions
fonksiyon cdc_write(data: Metin)
fonksiyon cdc_write_bytes(data: Dizi<sayı8>)
fonksiyon cdc_read() -> Dizi<sayı8>
fonksiyon cdc_set_rx_callback(callback: fonksiyon(Dizi<sayı8>))

// HID Functions
fonksiyon hid_send_report(report: Dizi<sayı8>)
fonksiyon hid_get_report() -> Dizi<sayı8>

// Status
fonksiyon get_state() -> USBState
fonksiyon is_active() -> mantık
fonksiyon poll()  // Process USB events

⚠️ Önemli Notlar:

48 MHz Clock: USB için tam 48 MHz clock gerekli (tolerance ±0.25%)
VID/PID: Production'da kendi VID/PID'nizi alın (USB-IF'den)
Enumeration Time: PC tanıma süresi 1-3 saniye sürebilir
Interrupt Priority: USB interrupt yüksek öncelikli olmalı

🖥️ Platform Desteği

Platform	USB Support	Speed	Endpoints
STM32F1	✅ FS	12 Mbps	8 EP
STM32F4	✅ FS/HS	12/480 Mbps	6 EP (FS), 8 EP (HS)
STM32F7	✅ FS/HS	12/480 Mbps	6 EP (FS), 8 EP (HS)
STM32H7	✅ FS/HS	12/480 Mbps	9 EP

✅ Best Practices

✅ CDC for debug: UART yerine USB CDC kullan (kablo gereksinimi aynı)
✅ HID for UI: Basit kontrol için HID keyboard/mouse kullan
✅ MSC for data: Log dosyaları için MSC kullan (FAT32)
✅ Disconnect before reset: Reset öncesi usb.disconnect() çağır
❌ Float operations: USB interrupt'ta floating-point kullanma
❌ Long callbacks: USB callback'leri kısa tutun (<1 ms)

🔗 İlgili Modüller

hal::clock - 48 MHz USB clock configuration
hal::gpio - USB D+/D- pin setup
hal::sdio - SD card for USB MSC backend
hal::dma - DMA for high-speed USB transfers

🔙 HAL Modülleri | 🌐 English

Keyboard shortcuts

BERK Programlama Dili