Close-up photograph of an Infineon AURIX TC3xx microcontroller chip mounted on an automotive PCB.

Prinsip Teknis dan Implementasi Teknik AURIX TC3xx LBIST (Logic Built-In Self-Test)

Tinggalkan Komentar / Technology Article / Oleh

Pengarang: Johnny Liu

Judul: CEO di Dowway Vehicle

Tanggal: 24 Juni 2026

Kategori: Elektronik Otomotif / Keselamatan Fungsional / Firmware Tertanam

Pertanyaan yang Sering Diajukan (FAQ) Singkat

Apa itu LBIST pada AURIX TC3xx? Ini adalah pengujian mandiri perangkat keras yang memeriksa gerbang logika digital mikrokontroler. Ia menggunakan rantai pemindaian internal, menjalankan pola uji pseudo-acak, dan membuat tanda tangan unik untuk memverifikasi bahwa perangkat keras tidak mengandung kesalahan struktural laten.

Mengapa menjalankan LBIST memicu Warm Reset? Tes pemindaian menimpa dan mengacak status sirkuit digital. Reset hangat diperlukan untuk membersihkan status yang tidak valid ini dan memboot sistem kembali ke keadaan yang bersih dan dapat diprediksi.

Di mana Anda menemukan tanda tangan emas untuk tes tersebut? Ini adalah nilai 32-bit statis yang telah dihitung sebelumnya. Anda dapat menemukan tanda tangan untuk jumlah pola dan frekuensi spesifik Anda di lampiran Unit Kontrol Sistem (SCU) pada Panduan Pengguna Infineon AURIX TC3xx.

Mengapa Panduan Ini Penting (Sudut Pandang ISO 26262)

Dalam desain otomotif yang kritis terhadap keselamatan (ASIL-B hingga ASIL-D), kita harus mendeteksi kesalahan perangkat keras secara acak. Kesalahan laten sangat berbahaya. Ini adalah kesalahan yang tetap tersembunyi selama pengoperasian normal tetapi dapat menyebabkan pelanggaran keselamatan jika terjadi kesalahan kedua.

Pengujian Mandiri Terintegrasi Logika (LBIST) adalah mekanisme keselamatan perangkat keras utama (SM:MCU:LBIST) pada AURIX TC3xx. Program ini menargetkan Latent Fault Metric (LFM). Karena program ini memeriksa gerbang inti digital, menjalankan LBIST yang berhasil memungkinkan kita untuk memverifikasi CPU, bus, dan pengontrol keselamatan saat booting. Hal ini menghilangkan kebutuhan akan pemeriksaan logika berbasis perangkat lunak yang lambat dan kompleks di kemudian hari.

Perbandingan Singkat Tes Mandiri Startup

Untuk menjaga desain Anda tetap rapi, jangan samakan LBIST dengan pengujian bawaan lainnya di platform ini:

Mekanisme PengujianApa yang DiujinyaPenyebab Reset?Kapan Harus Menjalankannya?Tujuan Utama
LBISTLogika Digital InternalYa (Reset Hangat)Boot Awal (Cold PORST / Standby Wakeup)Mendeteksi kerusakan struktural gerbang untuk LFM
MBISTMemori SRAM dan FlashTIDAK (Dapat dikonfigurasi)Startup atau RuntimeMendeteksi kegagalan sel memori dan jalur alamat
MONBISTMonitor Tegangan PMSTIDAKSepatu Boot AwalMemverifikasi jalur cadangan monitor tegangan
FwCheckKonfigurasi Register UtamaTIDAKSetelah Reset / Waktu EksekusiMemeriksa register dan jejak firmware.

Cara Kerja TC3xx LBIST di Perangkat Keras

Rantai Pemindaian dan Kompresi Tanda Tangan

LBIST mengandalkan pengujian pemindaian struktural. Selama proses manufaktur, perancang chip menghubungkan flip-flop internal bersama-sama untuk membentuk register serial yang disebut rantai pemindaian.

+---------------------------------------------------------------------------------+
|                                 AURIX TC3xx SCU                                 |
|                                                                                 |
|   +-------------------+    Test Patterns    +-------------------------------+   |
|   |   LFSR Engine     |====================>|       Internal Scan Chains    |   |
|   | (Seed & Patterns) |                     | (Registers linked in series)  |   |
|   +-------------------+                     +-------------------------------+   |
|                                                             ||                  |
|                                                             || Capture & Shift  |
|                                                             \/                  |
|   +-------------------+     Final Signature   +-------------------------------+   |
|   |   LBISTCTRL3      |<====================|         MISR Compressor       |   |
|   |  (SIGNATURE)      |                     | (Compresses output stream)    |   |
|   +-------------------+                     +-------------------------------+   |
+---------------------------------------------------------------------------------+

Perangkat keras tersebut mengikuti siklus yang bersih dan otomatis:

  1. Menghasilkan Pola: Register Geser Umpan Balik Linier (LFSR) menciptakan pola uji pseudo-acak berdasarkan nilai awal ( Benih).
  2. Pindah Masuk: Pengontrol menggeser pola-pola ini ke dalam rantai pemindaian internal.
  3. Fase Penangkapan: Sistem ini menjalankan satu atau lebih jam fungsional. Gerbang logika memproses pola, dan flip-flop menangkap outputnya.
  4. Menggeser Keluar & Memampatkan: Data yang ditangkap kemudian masuk ke Register Tanda Tangan Masukan Ganda (MISR), yang memampatkan aliran bit yang panjang menjadi satu bit tunggal. Tanda tangan 32-bit.
  5. Mengevaluasi: Perangkat lunak membandingkan tanda tangan ini dengan nilai acuan untuk memastikan perangkat keras dalam kondisi sehat.

Apa yang Tidak Dicakup oleh LBIST

Perhatikan batasan perangkat keras berikut:

  • Modul Analog: Ini tidak menguji blok analog PMS, EVR, atau ADC.
  • Isi SRAM: Pengujian memori diserahkan kepada MBIST. Karena LBIST mengacak perangkat keras, hal itu merusak register Unit Pengujian Memori (MTU) tertentu. Perangkat lunak Anda harus mencadangkan dan memulihkan nilai register ini.

Register Perangkat Keras yang Perlu Diketahui

Mengonfigurasi pengujian berarti menulis ke register di Unit Kontrol Sistem (SCU). Penulisan ini dilindungi oleh Pengakhiran Keselamatan (SEINIT) untuk mencegah eksekusi yang tidak disengaja.

  • LBISTCTRL0 (Kontrol 0): Berisi bit pemicu redundan (LBISTREQ Dan LBISTREQRED), bit reset pengontrol (LBISTRES), dan bendera penyelesaian (LBISTDONE).
  • LBISTCTRL1 (Kontrol 1): Mengatur pembagi frekuensi jam uji (FREKUENSI), tata letak struktural logika (TUBUH), mengubah batas kecepatan untuk mengelola lonjakan arus (MEMISAHKAN), dan benih LFSR (BENIH).
  • LBISTCTRL2 (Kontrol 2): Menentukan jumlah pola uji yang akan dijalankan (PANJANG).
  • LBISTCTRL3 (Kontrol 3): Berisi tanda tangan uji 32-bit terakhir (TANDA TANGAN).
  • RSTSTAT (Reset Status): Memantau bagaimana tes berakhir melalui LBTERM (tes berakhir normal) dan LBPORST (pengujian tidak terputus oleh reset daya) bendera.

Batas Reset Hangat

Perangkat keras selalu memaksa sistem untuk melakukan Warm Reset ketika pengujian selesai. Ini adalah pilihan desain perangkat keras yang disengaja.

Karena uji pemindaian memaksakan nilai acak melalui chip, keadaan internal gerbang logika menjadi tidak valid. Warm Reset membersihkan semua register dan memulai MCU dari keadaan yang bersih.

Meskipun SRAM mempertahankan datanya melalui Warm Reset, reset tersebut merusak sebagian dari MTU. Perangkat lunak harus menangani transisi ini dengan hati-hati.

Merancang Mesin Keadaan Reset Silang

Karena pengujian memicu Warm Reset, Anda harus membagi driver perangkat lunak Anda menjadi dua bagian: Fase Pemicu Pra-Reset dan Fase Analisis Pasca-Reset.

                    +--------------------+
                    |     Power On       |
                    +--------------------+
                              |
                              v
                  +------------------------+
                  |  Read RSTSTAT Register |
                  +------------------------+
                              |
               Is Cold PORST or Standby Wakeup?
               /                              \
             YES                               NO
             /                                  \
            v                                    v
  +------------------+                 +--------------------+
  | Check Persistent |                 | Skip LBIST & Boot  |
  |   Context State  |                 +--------------------+
  +------------------+
    /     |      \
 START   RUN    PASS/FAIL (Terminal States)
  /       |        \_______________________
 v        v                                \
[Trigger] [Analyze Signature]               v
          /       \               +--------------------+
       Valid     Invalid          | Continue app boot  |
        /           \             +--------------------+
       v             v
  Set PASS       Retries < 3?
  Clear Flags     /       \
  App Boot      YES        NO
                 /          \
                v            v
           Increment      Set FAIL
         Retry Counter   Enter Safe State
          Re-Trigger

1. Menyiapkan Penyimpanan Permanen

Untuk mengirimkan informasi status melalui Warm Reset, Anda memerlukan blok memori kecil yang tidak terhapus selama reset. Pada AURIX TC3xx, kami menggunakan segmen khusus dari DLMU SRAM Dikonfigurasi untuk mempertahankan daya dalam mode siaga.

Berikut cara Anda dapat mengatur blok memori ini di C:

typedef enum {
    LBIST_STATE_START = 0xA5A5A5A5U,
    LBIST_STATE_RUN   = 0x5A5A5A5AU,
    LBIST_STATE_PASS  = 0x3C3C3C3CU,
    LBIST_STATE_FAIL  = 0xC3C3C3C3U
} LbistState_t;

typedef struct {
    LbistState_t state;
    uint32_t     retryCounter;
    uint32_t     callerIntentCheck; // Prevents wild triggers via a CRC
    uint32_t     lastFailureReason;
} LbistPersistedContext_t;

/* Map this struct to a non-initialized retention RAM area */
__attribute__((section(".bss.backup_ram_noinit"))) 
volatile LbistPersistedContext_t g_LbistContext;

2. Alur dan Langkah-langkah Perangkat Lunak

Fase A: Pemicu Pra-Reset

  1. Penyebab Reset Pemeriksaan: Membaca RSTSTAT. Hanya jalankan pengujian jika pengaturan ulang adalah PORT Dingin atau sebuah Siaga Bangun. Lewati langkah ini untuk pengaturan ulang yang dipicu oleh perangkat lunak.
  2. Baca Kondisi Terkini: Membaca g_LbistContext.state. Saat booting dingin, inisialisasi ini ke LBIST_STATE_START.
  3. Daftar MTU Cadangan: Simpan semua status register MTU penting ke RAM retensi sehingga Anda dapat memulihkannya setelah pengaturan ulang.
  4. Konfigurasi Perangkat Keras: Nonaktifkan interupsi. Buka kunci perlindungan Safety Endinit (UnlockSEINIT()). Tulis konfigurasi seed, frekuensi, dan jumlah pola ke LBISTCTRL1 Dan LBISTCTRL2.
  5. Verifikasi Niat Tulis: Hitung CRC dari konfigurasi dan tuliskan ke g_LbistContext.callerIntentCheck. Hal ini mencegah bug perangkat lunak yang tidak terduga memicu pengujian secara tidak sengaja.
  6. Atur Status ke RUN: Menulis LBIST_STATE_RUN ke g_LbistContext.state.
  7. Pemicu Berlebihan: Menulis 1 untuk keduanya LBISTCTRL0.LBISTREQ Dan LBISTCTRL0.LBISTREQRED dalam siklus jam yang sama.
  8. Kunci CPU: Masuk ke dalam lingkaran perakitan tak terbatas (sementara(1);) dan tunggu hingga proses reset perangkat keras selesai.

Fase B: Analisis Pasca-Reset

  1. Entri Boot: MCU melakukan booting. Perangkat lunak membaca… RSTSTAT dan mendeteksi Warm Reset.
  2. Periksa Status: Perangkat lunak tersebut membaca g_LbistContext.state dan mendapati bahwa itu diatur ke LBIST_STATE_RUN.
  3. Verifikasi Niat: Hitung CRC dan bandingkan dengan g_LbistContext.callerIntentCheck. Jika tidak cocok, tandai kesalahan kerusakan data dan lewati pengujian untuk menghindari pengulangan proses booting.
  4. Periksa Bendera: Konfirmasikan bahwa RSTSTAT.LBTERM == 1, RSTSTAT.LBPORST == 0, Dan LBISTCTRL0.LBISTDONE == 1.
  5. Verifikasi Tanda Tangan: Bacalah tanda tangan dari LBISTCTRL3.SIGNATURE dan bandingkan dengan nilai emas.
    • Jika cocok: Atur status menjadi LBIST_STATE_PASS. Setel ulang pengontrol LBIST melalui LBISTRES. Hapus flag Cold Reset di RSTSTAT untuk mencegah pengujian diulang pada reset hangat berikutnya. Pulihkan register MTU dan jalankan aplikasi.
    • Jika tidak cocok: Jalankan logika percobaan ulang.

3. Implementasi Produksi C

Berikut adalah implementasi driver yang bersih dan siap produksi:

#include "tc3xx_scu_registers.h"

#define GOLDEN_LBIST_SIGNATURE    0x2E4A9F18U  // Golden signature from User Manual
#define MAX_LBIST_RETRIES         3U

void Handle_Fatal_Safety_Fault(uint32_t reason) {
    // Notify the SMU and transition the ECU to a safe state
    while (1);
}

void Execute_LBIST_Evaluation_Sequence(void) {
    uint32_t rststat = SCU_RSTSTAT.U;
    
    // Check if the reset source is Cold PORST or Standby Exit
    if ((rststat & SCU_RSTSTAT_COLD_RESET_MASK) != 0U) {
        
        // Safe initialization check for retention RAM
        if (g_LbistContext.state == 0xFFFFFFFFU) { 
            g_LbistContext.state = LBIST_STATE_START;
            g_LbistContext.retryCounter = 0U;
        }

        switch (g_LbistContext.state) {
            case LBIST_STATE_START: {
                Backup_MTU_Configuration();

                // Unlock Safety Endinit and write configurations
                Unlock_Safety_Endinit();
                SCU_LBISTCTRL1.U = (0x1U << 16) | (0x0U << 8) | 0x5A5A5A5AU; // SPLITSH, BODY, SEED
                SCU_LBISTCTRL2.U = 0x000003E8U;                            // LENGTH (1000 Patterns)
                Lock_Safety_Endinit();

                // Protect against wild software jumps
                g_LbistContext.callerIntentCheck = Calculate_CRC32((uint8_t*)&g_LbistContext, sizeof(g_LbistContext) - 8);
                g_LbistContext.state = LBIST_STATE_RUN;

                // Redundant trigger write
                Unlock_Safety_Endinit();
                SCU_LBISTCTRL0.U |= (1U << SCU_LBISTCTRL0_LBISTREQ_POS) | (1U << SCU_LBISTCTRL0_LBISTREQRED_POS);
                Lock_Safety_Endinit();

                // Wait for hardware reset
                while (1) {
                    __nop();
                }
                break;
            }

            case LBIST_STATE_RUN: {
                // Verify caller intent CRC
                uint32_t calc_crc = Calculate_CRC32((uint8_t*)&g_LbistContext, sizeof(g_LbistContext) - 8);
                if (calc_crc != g_LbistContext.callerIntentCheck) {
                    g_LbistContext.state = LBIST_STATE_FAIL;
                    Handle_Fatal_Safety_Fault(0xFEED0001U); 
                    return;
                }

                // Verify hardware flags
                uint32_t test_done = (SCU_LBISTCTRL0.U & (1U << SCU_LBISTCTRL0_LBISTDONE_POS));
                uint32_t normal_term = (rststat & (1U << SCU_RSTSTAT_LBTERM_POS));
                uint32_t power_interrupted = (rststat & (1U << SCU_RSTSTAT_LBPORST_POS));

                if ((test_done != 0U) && (normal_term != 0U) && (power_interrupted == 0U)) {
                    uint32_t signature = SCU_LBISTCTRL3.U;

                    if (signature == GOLDEN_LBIST_SIGNATURE) {
                        g_LbistContext.state = LBIST_STATE_PASS;
                        
                        // Reset the controller and clear reset flags
                        Unlock_Safety_Endinit();
                        SCU_LBISTCTRL0.U |= (1U << SCU_LBISTCTRL0_LBISTRES_POS); 
                        SCU_RSTCON.U     |= SCU_RSTCON_CLEAR_COLD_FLAGS_MASK;    
                        Lock_Safety_Endinit();

                        Restore_MTU_Configuration();
                        return; // Continue to main boot
                    }
                }

                // Run retry strategy
                g_LbistContext.retryCounter++;
                if (g_LbistContext.retryCounter >= MAX_LBIST_RETRIES) {
                    g_LbistContext.state = LBIST_STATE_FAIL;
                    Handle_Fatal_Safety_Fault(0xFEED0002U); // Hardware error
                } else {
                    Unlock_Safety_Endinit();
                    SCU_LBISTCTRL0.U |= (1U << SCU_LBISTCTRL0_LBISTRES_POS);
                    Lock_Safety_Endinit();
                    
                    g_LbistContext.state = LBIST_STATE_START;
                    Execute_LBIST_Evaluation_Sequence(); // Re-run
                }
                break;
            }

            case LBIST_STATE_PASS:
                // Passed; continue standard boot
                break;

            case LBIST_STATE_FAIL:
            default:
                Handle_Fatal_Safety_Fault(0xFEED0003U);
                break;
        }
    }
}

Jebakan Rekayasa Praktis

1. Pengaturan Daya SRAM Siaga

Selama mode Standby, sistem mungkin mematikan daya ke RAM retensi Anda. Jika ini terjadi, variabel status Anda akan direset, dan MCU akan memicu pengujian baru setiap kali bangun, menyebabkan loop boot tak berujung.

  • Cara memperbaikinya: Konfigurasikan STBYRAMSEL Dan PROCONRAM.LMUINSEL register di SCU untuk memaksa sektor RAM LMU tetap menyala selama Standby. Selain itu, pastikan skrip linker Anda menempatkan g_LbistContext variabel dalam sebuah noinit bagian ini agar kode inisialisasi C saat startup tidak menghapusnya saat bangun dari mode tidur.

2. Jebakan Akses Data Awal

Membaca sektor SRAM yang belum diinisialisasi tepat setelah booting dingin dapat menyebabkan Jebakan Akses Data pada beberapa tahapan silikon AURIX karena ECC atau bit paritas yang buruk.

  • Cara memperbaikinya: Penanganan trap Anda harus memeriksa apakah pengecualian terjadi di ruang memori retensi selama proses booting awal. Jika ya, tulis data dummy untuk menginisialisasi bit ECC, bersihkan status trap, dan lanjutkan eksekusi alih-alih menghentikan CPU.

3. Koordinasi Boot Multi-Core

AURIX adalah platform multi-core. Jika semua core melakukan booting secara bersamaan selama siklus Warm Reset, hal itu dapat mengganggu state machine Anda.

  • Cara memperbaikinya: Atur urutan boot master-slave. Tahan semua core tambahan dalam keadaan berhenti (menggunakan Boot Mode Headers atau kontrol SCU) selama proses startup. Hanya izinkan Inti 0 untuk menjalankan mesin status LBIST. Setelah Core 0 memverifikasi pengujian dan menulis LBIST_STATE_PASS, hal itu dapat membebaskan inti prosesor lainnya untuk melakukan booting.

Pengujian dan Validasi Laboratorium

Untuk memverifikasi desain Anda kepada penilai keselamatan fungsional, Anda dapat menggunakan metode pengujian berikut:

  • Verifikasi Jalur Emas: Gunakan debugger Anda untuk memastikan mesin status berhasil menyelesaikan transisi: $$\text{START} \longrightarrow \text{Warm Reset} \longrightarrow \text{RUN} \longrightarrow \text{PASS}$$
  • Kesalahan Injeksi Data: Hentikan CPU selama AWAL fase, secara manual merusak g_LbistContext.callerIntentCheck CRC di memori, dan lanjutkan. Konfirmasikan bahwa perangkat lunak menangkap kesalahan dan beralih ke keadaan aman tanpa menjalankan pengujian.
  • Suntikkan Kegagalan Tanda Tangan: Ubah konfigurasi pengujian Anda sedikit (misalnya, mengubah jumlah pola di LBISTCTRL2). Ini akan mengubah tanda tangan. Pastikan bahwa:
    1. Kode tersebut mencoba menjalankan pengujian hingga 3 kali.
    2. MCU memasuki kondisi aman pada percobaan gagal ketiga.

Kesimpulan

Menjalankan LBIST pada AURIX TC3xx adalah cara yang sangat andal untuk memenuhi persyaratan diagnostik ISO 26262 untuk logika digital. Dengan menggunakan rantai pemindaian internal dan pola pseudo-acak, perangkat keras tersebut dapat menentukan lokasi kegagalan struktural gerbang.

Untuk menjalankannya dengan aman, Anda harus membangun mesin status reset silang yang bersih. Fokuslah pada melindungi konfigurasi RAM retensi Anda, mengelola jebakan startup, mengoordinasikan inti CPU Anda, dan menetapkan batas percobaan ulang yang solid. Ini memastikan pengujian mandiri Anda aman dan dapat diandalkan.

Tinggalkan Komentar

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *

Need a Quote or Have Questions?

Please fill out the form below, our engineers will contact you within 24 hours.