🔐 hal::crc

Hardware CRC32 Calculator - Fast Data Integrity Check

~360 satır ~12 fonksiyon STM32/GD32

📖 Genel Bakış

CRC modülü, hardware accelerated CRC32 hesaplaması sağlar. Polynomial 0x04C11DB7 kullanır (Ethernet standardı). Firmware integrity check, flash verification, communication protocols ve data corruption detection için kritiktir. Software CRC'den 10-100x daha hızlıdır.

🔑 Temel Özellikler

Hardware CRC32: Single-cycle 32-bit CRC calculation
Standard Polynomial: 0x04C11DB7 (Ethernet, ZIP, PNG)
Fast Performance: 1 clock cycle per 32-bit word
Initial Value: Configurable (default 0xFFFFFFFF)
DMA Compatible: Can be used with DMA transfers
Accumulation: Sequential CRC calculation support
Reset Capability: Quick reset to initial value
Low Power: Minimal power consumption

🚀 Hızlı Başlangıç

içe_aktar hal::crc, hal::rcc

// Enable CRC clock
rcc.periph_clock_enable(rcc.PERIPH_CRC)

// Initialize CRC
crc.init()

// Calculate CRC32 of data
değişken data: Dizi<sayı> = [0x12345678, 0xABCDEF00, 0xDEADBEEF]
değişken checksum = crc.calculate(data)

io.yazdir_satır("CRC32: 0x" + checksum.onaltılıya())

// Verify data
eğer crc.verify(data, checksum) yap
    io.yazdir_satır("Data integrity OK")
son

📦 Tipler ve Enum'lar

// CRC Configuration
yapı CRCConfig yap
    polynomial: sayı = 0x04C11DB7,  // Default Ethernet polynomial
    initial_value: sayı = 0xFFFFFFFF,
    input_reverse: mantık = yanlış,
    output_reverse: mantık = yanlış
son

// CRC Result
yapı CRCResult yap
    value: sayı,
    valid: mantık
son

💡 Örnek 1: Firmware Integrity Check

Problem: Flash'taki firmware'in bozulmadığını doğrulamak

içe_aktar hal::crc, hal::flash

sabit FIRMWARE_START: sayı = 0x0800_8000  // Application start
sabit FIRMWARE_SIZE: sayı = 128 * 1024     // 128 KB
sabit CRC_STORAGE: sayı = 0x0807_FFFC      // Last 4 bytes of app region

fonksiyon firmware_calculate_crc() -> sayı yap
    crc.reset()
    
    // Calculate CRC of firmware (32-bit words)
    değişken word_count = FIRMWARE_SIZE / 4
    değişken addr = FIRMWARE_START
    
    için i içinde 0..word_count yap
        değişken word = *(addr kayıt *sayı)
        crc.accumulate(word)
        addr = addr + 4
    son
    
    dön crc.get_value()
son

fonksiyon firmware_store_crc(checksum: sayı) yap
    // Unlock flash
    flash.unlock()
    
    // Erase last page
    flash.erase_page(CRC_STORAGE)
    
    // Write CRC
    flash.program_word(CRC_STORAGE, checksum)
    
    flash.lock()
    
    io.yazdir_satır("CRC stored: 0x" + checksum.onaltılıya())
son

fonksiyon firmware_verify() -> mantık yap
    // Read stored CRC
    değişken stored_crc = *(CRC_STORAGE kayıt *sayı)
    
    // Calculate current CRC
    değişken calculated_crc = firmware_calculate_crc()
    
    io.yazdir_satır("Stored CRC:     0x" + stored_crc.onaltılıya())
    io.yazdir_satır("Calculated CRC: 0x" + calculated_crc.onaltılıya())
    
    eğer stored_crc == calculated_crc yap
        io.yazdir_satır("✅ Firmware integrity OK")
        dön doğru
    yoksa yap
        io.yazdir_satır("❌ Firmware corrupted!")
        dön yanlış
    son
son

fonksiyon ana() yap
    crc.init()
    
    // On firmware update: store CRC
    // firmware_store_crc(firmware_calculate_crc())
    
    // On boot: verify firmware
    eğer değil firmware_verify() yap
        io.yazdir_satır("ERROR: Cannot start corrupted firmware")
        // Enter safe mode or bootloader
        döngü yap son  // Halt
    son
    
    io.yazdir_satır("Starting application...")
son

Sonuç: Boot sırasında firmware corruption detect edilir. Güvenli başlatma sağlanır.

💡 Örnek 2: UART Packet Verification

Problem: Serial communication'da packet integrity kontrolü

içe_aktar hal::crc, hal::usart

yapı Packet yap
    header: sayı8 = 0xAA,
    length: sayı8,
    data: Dizi<sayı8>,
    crc32: sayı
son

fonksiyon packet_calculate_crc(pkt: Packet) -> sayı yap
    crc.reset()
    
    // CRC over header + length + data
    crc.accumulate_byte(pkt.header)
    crc.accumulate_byte(pkt.length)
    
    için byte içinde pkt.data yap
        crc.accumulate_byte(byte)
    son
    
    dön crc.get_value()
son

fonksiyon packet_send(pkt: Packet) yap
    // Calculate CRC
    pkt.crc32 = packet_calculate_crc(pkt)
    
    // Send packet
    usart.write_byte(usart.USART1, pkt.header)
    usart.write_byte(usart.USART1, pkt.length)
    
    için byte içinde pkt.data yap
        usart.write_byte(usart.USART1, byte)
    son
    
    // Send CRC (big-endian)
    usart.write_byte(usart.USART1, (pkt.crc32 >> 24) & 0xFF kayıt sayı8)
    usart.write_byte(usart.USART1, (pkt.crc32 >> 16) & 0xFF kayıt sayı8)
    usart.write_byte(usart.USART1, (pkt.crc32 >> 8) & 0xFF kayıt sayı8)
    usart.write_byte(usart.USART1, pkt.crc32 & 0xFF kayıt sayı8)
son

fonksiyon packet_receive() -> Seçenek<Packet> yap
    // Read header
    değişken header = usart.read_byte(usart.USART1)
    eğer header != 0xAA yap
        dön Seçenek.Hiçbiri
    son
    
    // Read length
    değişken length = usart.read_byte(usart.USART1)
    
    // Read data
    değişken data = Dizi.yeni(length)
    için i içinde 0..length yap
        data[i] = usart.read_byte(usart.USART1)
    son
    
    // Read CRC
    değişken crc_recv = 0 kayıt sayı
    crc_recv = (crc_recv << 8) | usart.read_byte(usart.USART1) kayıt sayı
    crc_recv = (crc_recv << 8) | usart.read_byte(usart.USART1) kayıt sayı
    crc_recv = (crc_recv << 8) | usart.read_byte(usart.USART1) kayıt sayı
    crc_recv = (crc_recv << 8) | usart.read_byte(usart.USART1) kayıt sayı
    
    // Create packet
    değişken pkt = Packet yap
        header: header,
        length: length,
        data: data,
        crc32: crc_recv
    son
    
    // Verify CRC
    değişken crc_calc = packet_calculate_crc(pkt)
    
    eğer crc_calc == crc_recv yap
        io.yazdir_satır("✅ Packet CRC OK")
        dön Seçenek.Bazı(pkt)
    yoksa yap
        io.yazdir_satır("❌ Packet CRC mismatch!")
        dön Seçenek.Hiçbiri
    son
son

Sonuç: UART üzerinden gelen corrupt paketler reddedilir. Data integrity garanti edilir.

💡 Örnek 3: SD Card File Verification

Problem: SD card'dan okunan dosyanın bozulmadığını kontrol etmek

içe_aktar hal::crc, hal::sdio

fonksiyon file_calculate_crc(filename: Metin) -> sayı yap
    // Open file
    değişken file = sdio.file_open(filename, sdio.MODE_READ)
    
    eğer değil file.is_valid() yap
        io.yazdir_satır("ERROR: Cannot open file")
        dön 0
    son
    
    crc.reset()
    
    // Read file in 512-byte blocks
    değişken buffer: Dizi<sayı8> = Dizi.yeni(512)
    
    döngü yap
        değişken bytes_read = sdio.file_read(file, buffer)
        
        eğer bytes_read == 0 yap
            kır  // EOF
        son
        
        // Process full 32-bit words
        için i içinde 0..(bytes_read/4) yap
            değişken word = (buffer[i*4] kayıt sayı) |
                           ((buffer[i*4+1] kayıt sayı) << 8) |
                           ((buffer[i*4+2] kayıt sayı) << 16) |
                           ((buffer[i*4+3] kayıt sayı) << 24)
            crc.accumulate(word)
        son
        
        // Handle remaining bytes
        değişken remainder = bytes_read % 4
        eğer remainder > 0 yap
            için i içinde (bytes_read - remainder)..bytes_read yap
                crc.accumulate_byte(buffer[i])
            son
        son
    son
    
    sdio.file_close(file)
    
    dön crc.get_value()
son

fonksiyon file_verify(filename: Metin, expected_crc: sayı) -> mantık yap
    io.yazdir_satır("Verifying " + filename + "...")
    
    değişken calculated = file_calculate_crc(filename)
    
    io.yazdir_satır("Expected:   0x" + expected_crc.onaltılıya())
    io.yazdir_satır("Calculated: 0x" + calculated.onaltılıya())
    
    dön calculated == expected_crc
son

Kullanım: Firmware update dosyalarının SD card'dan okunurken bozulmadığını garanti eder.

📚 API Referansı

Temel Fonksiyonlar

// CRC initialization
fonksiyon init()
fonksiyon deinit()
fonksiyon reset()  // Reset to initial value

// CRC calculation
fonksiyon calculate(data: Dizi<sayı>) -> sayı
fonksiyon accumulate(word: sayı)  // Add 32-bit word
fonksiyon accumulate_byte(byte: sayı8)  // Add 8-bit byte

// Get result
fonksiyon get_value() -> sayı

// Verification
fonksiyon verify(data: Dizi<sayı>, expected: sayı) -> mantık

⚠️ Önemli Notlar:

Word Alignment: CRC hardware 32-bit word aligned çalışır
Byte Order: Little-endian işlemci için byte order dikkat edilmeli
Initial Value: Reset sonrası 0xFFFFFFFF (not 0x00000000)
Final XOR: Bazı protokoller final XOR 0xFFFFFFFF gerektirir

🖥️ Platform Desteği

Platform	CRC Support	Polynomial	Speed
STM32F1	✅ Var	0x04C11DB7	1 cycle/word
STM32F4	✅ Var	0x04C11DB7	1 cycle/word
STM32F7	✅ Var	Configurable	1 cycle/word
STM32H7	✅ Var	Configurable	1 cycle/word
GD32VF103	✅ Var	0x04C11DB7	1 cycle/word

✅ Best Practices

✅ Firmware check: Boot sırasında firmware CRC kontrolü yap
✅ Communication: Paketlerde CRC kullan (especially wireless)
✅ Storage: Flash/SD card'dan okunan veriler için CRC
✅ Reset before use: Her hesaplama öncesi crc.reset() çağır
❌ Not for crypto: CRC security için değil, error detection için
❌ Byte alignment: Non-aligned erişim performans kaybı yaratır

🔗 İlgili Modüller

hal::flash - Firmware integrity verification
hal::usart - UART packet CRC
hal::sdio - SD card file verification
hal::dma - DMA with CRC calculation

🔙 HAL Modülleri | 🌐 English