Skip to content
TheChatArchiveThe Chat Archive
o3-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

در مورد stm 32 توضیح بده

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514’s answer.
  1. User

    در مورد stm 32 توضیح بده

  2. Assistant

    آشنایی جامع با خانواده میکروکنترلرهای STM32

    STM32 نام یک خانوادهٔ بزرگ از میکروکنترلرهای ۳۲-بیتی شرکت STMicroelectronics است که بر پایهٔ هسته‌های ARM Cortex ساخته شده‌اند. این خانواده طیف بسیار گسترده‌ای از نیازهای صنعتی، مصرفی، پزشکی، اینترنت اشیا (IoT)، خودرو و … را پوشش می‌دهد.


    ۱. چرا STM32؟

    • تنوع بسیار بالا (از 16KB تا چند مگابایت فلش، از 2 تا 1 MB RAM، از 16 تا 550+ پین I/O)
    • توان مصرفی بهینه (سری‌های کم‌مصرف مثل L0/L4/U5)
    • کارایی بالا (سری‌های F7/H7 با فرکانس 480 MHz و واحدهای شتاب‌دهنده سخت‌افزاری)
    • پشتیبانی نرم‌افزاری قوی (CubeMX, CubeIDE, HAL/LL, CMSIS)
    • منابع یادگیری و کامیونیتی گسترده
    • قیمت رقابتی نسبت به میکروکنترلرهای هم‌رده

    ۲. دسته‌بندی خانواده‌های اصلی

    خانوادههستهمحدوده فرکانستوان/کارایینکات شاخص
    STM32F0Cortex-M0/M0+تا 48 MHzاقتصادیمناسب پروژه‌های ساده، جایگزین AVR/PIC
    STM32G0Cortex-M0+تا 64 MHzکم‌هزینه امنUSB-C PD، درگاه‌های متعدد آنالوگ
    STM32F1Cortex-M3تا 72 MHzکلاسیکمحبوب‌ترین در آموزش (مثلاً Blue Pill)
    STM32F3Cortex-M4تا 72 MHzسیگنال مختلطADC سریع 5 Msps، FPU اختیاری
    STM32F4Cortex-M4تا 180 MHzهمه‌منظوره قدرتمندDSP/FPU کامل، اترنت، LCD
    STM32F7Cortex-M7تا 216 MHzکارایی بالاL1-Cache، شتاب‌دهنده گرافیک
    STM32H7Cortex-M7/M4تا 480 MHzHigh-PerformanceDual-core، پشتیبانی از DDR, JPEG
    STM32L0Cortex-M0+تا 32 MHzفوق کم‌مصرف42nA Shutdown، USB FS
    STM32L4Cortex-M4تا 120 MHzکم‌مصرف/کاراکلاک تطبیقی، TFT-LCD
    STM32U5Cortex-M33تا 160 MHzفوق کم‌مصرف نسل جدیدSecure Boot, TrustZone
    STM32G4Cortex-M4تا 170 MHzکنترل موتور, PowerDAC 12bit دوکاناله سریع
    STM32WBCortex-M4+M0+تا 64 MHzبلوتوث/802.15.4MCU دو هسته برای شبکه و اپ
    STM32WLCortex-M4تا 48 MHzLoRa/FSKرادیوی داخلی Sub-GHz

    ۳. واحدها و امکانات کلیدی

    1. هسته ARM Cortex با حالت‌های خواب عمیق (Sleep/Stop/Standby).
    2. تایمرهای پیشرفته (PWM، Encoder Interface، One-Pulse).
    3. مبدل‌های ADC 12/14-بیتی و DAC 12-بیتی با سرعت بالا.
    4. رابط‌های دیجیتال متنوع:
      • GPIO با امکان ریمپینگ/AF
      • UART/USART + LIN/IrDA/SmartCard
      • SPI/I2S، I²C، CAN/CAN-FD، USB OTG FS/HS، Ethernet, SDIO
    5. واحدهای ارتباط بی‌سیم داخلی (سری‌های WB/WL).
    6. شتاب‌دهنده‌های سخت‌افزاری: CRC، RNG، AES، HASH، JPEG، ART Accelerator.
    7. RTC با باتری بک‌آپ، Watchdogها، Brown-out Reset.
    8. بسته‌های امنیتی: TrustZone, Root of Trust, Secure Boot, HSM.

    ۴. اکوسیستم نرم‌افزاری

    🛠️ ابزار رسمی ST:

    1. STM32CubeIDE (‌IDE‌ یکپارچه مبتنی بر Eclipse + GCC + GDB)
    2. STM32CubeMX (کانفیگ گرافیکی پین/کلاک/پریفرال → تولید کد)
    3. HAL Drivers (High-Abstraction Layer) و LL Drivers (Low-Layer)
    4. STM32CubeProgrammer (فلش و رمزگذاری)
    5. ST-Link Utility / ST-Link Server

    ابزارهای شخص ثالث:

    • Keil MDK-ARM, IAR EWARM, SEGGER Embedded Studio
    • ابزارهای متن‌باز: PlatformIO، Zephyr RTOS، MicroPython، Mbed OS
    • Debug Probeها: ST-Link V2/V3، J-Link، CMSIS-DAP

    ۵. بوردهای توسعه محبوب

    دستهمثالتوضیح
    DiscoverySTM32F429I-DISC1LCD رنگی، دوربین، مموری
    NucleoNUCLEO-F401REآردوینو هدر + ST-Link آنبورد
    Eval BoardSTM32H743I-EVALفول آپشن صنعتی
    Third-PartyBlue/Black Pill (F103C8)ارزان، هکرپسند

    ۶. مسیر یادگیری پیشنهادی

    1. مفاهیم پایه میکروکنترلر و ARM Cortex-M.
    2. کار با CubeMX برای پیکربندی اولیه یک بورد Nucleo.
    3. تمرین GPIO (روشن/خاموش LED‌ها) → تایمر PWM → UART printf.
    4. مطالعه HAL Driver و سپس آشنایی با LL یا رجیستری خام.
    5. دیباگ با SWD و استفاده از printf-style semihosting یا ITM.
    6. پروژه‌های پیشرفته‌تر:
      • راه‌اندازی TFT یا دوربین (DCMI)
      • اتصال به شبکه (LWIP روی Ethernet یا MQTT روی Wi-Fi)
      • بهینه‌سازی مصرف انرژی (Stop Mode + RTC Wake-Up)

    ۷. نکات خرید و انتخاب

    1. ابتدا کاربرد و محدودیت‌ها (توان/مصرف/هزینه/دما) را مشخص کنید.
    2. به مدار چاپی نگاه کنید: پکیج LQFP48 برای نمونه‌سازی دستی مناسب‌تر از BGA.
    3. منابع در دسترس: داکیومنت‌ها (Datasheet, Reference Manual, AN).
    4. موجودی بازار: سری‌های جدید G4/U5 شاید در همه کشورها نباشد.
    5. لایسنس نرم‌افزار: اگر Keil/IAR نمی‌خرید، CubeIDE کاملاً رایگان است.

    ۸. مزایا و چالش‌ها

    🌟 مزایا
    • جامعه کاربری بزرگ، مثال‌های فراوان
    • مستندات مفصل و Application Noteهای ST
    • پشتیبانی سخت‌افزاری از DSP، گرافیک، رمزنگاری

    ⚠️ چالش‌ها
    • گاهی HAL سنگین و کند است → نیاز به LL/RG
    • پیچیدگی در خانواده‌های پرامکانات (H7)
    • نسخه‌های متفاوت Cube ممکن است باگ داشته باشد → به‌روزرسانی منظم لازم است


    ۹. منابع یادگیری فارسی و انگلیسی

    • کانال‌ها و انجمن‌های تلگرام/آپارات «STM32 ایران»
    • کتاب «Discovering STM32» (از Prof. Geoffrey Brown)
    • LearnSTM32.com و سایت stm32world.com
    • دوره‌های ST (MOOC) در st.com/academy
    • یوتیوب: «ControllersTech», «Phil’s Lab», «Shahin Ramezani»

    جمع‌بندی

    STM32 به دلیل تنوع بی‌نظیر، اکوسیستم نرم‌افزاری قوی و دسترسی آسان به ابزارهای حرفه‌ای، یکی از بهترین گزینه‌ها برای ورود و همچنین پیشرفت در دنیای سیستم‌های نهفته است. بسته به نیاز می‌توانید از تراشه‌های اقتصادی F0/G0 تا غول‌های پرقدرت H7/U5 بهره ببرید و به کمک CubeIDE و بوردهای Nucleo/Discovery در کمترین زمان ایدهٔ خود را به محصول تبدیل کنید. موفق باشید! 🚀

  3. User

    کد nrf24 برای stm 32 میخوام

  4. Assistant

    در این پاسخ یک کتابخانه‌ی ساده‌ی «آماده برای کامپایل» (C) جهت راه‌اندازی ماژول بی‌سیم Nordic nRF24L01+ روی میکروکنترلرهای STM32 (مبتنی بر HAL/CubeMX) ارائه می‌شود.

    • مناسب تمام خانواده‌های STM32 (F0-F1-F4-G0-…)، فقط کافی‌ست نام پورت/پین و هندل SPI را در فایل هدر تغییر دهید.
    • بدون وقفه (IRQ) هم کار می‌کند؛ ولی در صورت نیاز می‌توانید IRQ را نیز فعال کنید.
    • برای شروع سریع: پروژه‌ی CubeIDE بسازید → SPI1 را روی حالت Full-Duplex Master قرار دهید → دو GPIO برای CE و CSN تعریف کنید → کد زیر را اضافه و Build/Flash کنید.


    ۱) اتصالات سخت‌افزاری پیشنهادی

    nRF24L01 Pinوظیفهاتصال به STM32
    VCC3.3 V (دقت کنید 5V نیست!)3.3 V
    GNDزمینGND مشترک
    CEChip Enableمثلاً PB0
    CSNChip Select (SPI CS)مثلاً PB1
    SCKSPI SCKPA5 (اگر از SPI1 پیش‌فرض F103 استفاده کنید)
    MOSISPI MOSIPA7
    MISOSPI MISOPA6
    IRQوقفه اختیاریPB2 (می‌توانید آزاد بگذارید)

    ۲) ساختار فایل‌ها

    project
    ├── Core
    │ └── Inc
    │ └── nrf24.h
    └── Core
    └── Src
    └── nrf24.c

    (فایل‌های main.c و … همان قالب CubeMX هستند)


    ۳) nrf24.h

    /*  nrf24.h  -  کتابخانه‌ی مینیمال برای nRF24L01+
     *  نویسنده: ChatGPT @ OpenAI
     *  مجوز: MIT
     */
    
    #ifndef NRF24_H_
    #define NRF24_H_
    
    #include "stm32f1xx_hal.h"   // در صورت استفاده از خانواده دیگر، تغییر دهید
    
    /*  تنظیم پورت/پین‌ها را اینجا عوض کنید  */
    #define NRF24_CE_PORT     GPIOB
    #define NRF24_CE_PIN      GPIO_PIN_0
    
    #define NRF24_CSN_PORT    GPIOB
    #define NRF24_CSN_PIN     GPIO_PIN_1
    
    #define NRF24_CE_HIGH()   HAL_GPIO_WritePin(NRF24_CE_PORT,  NRF24_CE_PIN,  GPIO_PIN_SET)
    #define NRF24_CE_LOW()    HAL_GPIO_WritePin(NRF24_CE_PORT,  NRF24_CE_PIN,  GPIO_PIN_RESET)
    #define NRF24_CSN_HIGH()  HAL_GPIO_WritePin(NRF24_CSN_PORT, NRF24_CSN_PIN, GPIO_PIN_SET)
    #define NRF24_CSN_LOW()   HAL_GPIO_WritePin(NRF24_CSN_PORT, NRF24_CSN_PIN, GPIO_PIN_RESET)
    
    /* هندل SPI که CubeMX تولید کرده است (مثلاً hspi1) */
    extern SPI_HandleTypeDef hspi1;      // اگر SPI دیگری دارید نام را عوض کنید
    #define NRF24_SPI         hspi1
    
    /* دستورات (گزیده) */
    #define NRF24_CMD_R_REGISTER         0x00
    #define NRF24_CMD_W_REGISTER         0x20
    #define NRF24_CMD_R_RX_PAYLOAD       0x61
    #define NRF24_CMD_W_TX_PAYLOAD       0xA0
    #define NRF24_CMD_FLUSH_TX           0xE1
    #define NRF24_CMD_FLUSH_RX           0xE2
    #define NRF24_CMD_REUSE_TX_PL        0xE3
    #define NRF24_CMD_NOP                0xFF
    
    /* ثبات‌ها */
    #define NRF24_REG_CONFIG             0x00
    #define NRF24_REG_EN_AA              0x01
    #define NRF24_REG_EN_RXADDR          0x02
    #define NRF24_REG_SETUP_AW           0x03
    #define NRF24_REG_SETUP_RETR         0x04
    #define NRF24_REG_RF_CH              0x05
    #define NRF24_REG_RF_SETUP           0x06
    #define NRF24_REG_STATUS             0x07
    #define NRF24_REG_RX_ADDR_P0         0x0A
    #define NRF24_REG_TX_ADDR            0x10
    #define NRF24_REG_RX_PW_P0           0x11
    #define NRF24_REG_FIFO_STATUS        0x17
    
    /* توابع عمومی */
    void     nrf24_init(void);
    void     nrf24_tx_mode(uint8_t* address, uint8_t channel);
    void     nrf24_rx_mode(uint8_t* address, uint8_t channel);
    uint8_t  nrf24_send(uint8_t *data, uint8_t len);          // 1=موفق، 0=خطا
    uint8_t  nrf24_is_data_available(void);
    void     nrf24_receive(uint8_t* data, uint8_t len);
    
    #endif /* NRF24_H_ */
    

    ۴) nrf24.c

    /*  nrf24.c  -  پیاده‌سازی ساده کتابخانه nRF24L01+
     *  نویسنده: ChatGPT
     */
    
    #include "nrf24.h"
    #include <string.h>
    
    /* توابع کمکی خصوصی */
    static uint8_t nrf24_read_reg(uint8_t reg);
    static void    nrf24_write_reg(uint8_t reg, uint8_t data);
    static void    nrf24_write_reg_multi(uint8_t reg, uint8_t* data, uint8_t len);
    static void    nrf24_read_reg_multi(uint8_t reg, uint8_t* data, uint8_t len);
    static void    nrf24_send_cmd(uint8_t cmd);
    
    /*  ==== پیاده‌سازی ====  */
    
    void nrf24_init(void)
    {
        /* CE کم، CSN بالا */
        NRF24_CE_LOW();
        NRF24_CSN_HIGH();
        
        HAL_Delay(5);   // طبق دیتاشیت حداقل 100ms بعد از پاورآپ بهتر است
        
        /* تنظیمات پایه */
        nrf24_write_reg(NRF24_REG_CONFIG,     0x0C); // PWR_UP=1, CRCO=1 (2byte), PRIM_RX=0
        nrf24_write_reg(NRF24_REG_EN_AA,      0x01); // Auto-ACK روی Pipe0
        nrf24_write_reg(NRF24_REG_EN_RXADDR,  0x01); // فقط Pipe0 فعال
        nrf24_write_reg(NRF24_REG_SETUP_AW,   0x03); // آدرس 5 بایتی
        nrf24_write_reg(NRF24_REG_SETUP_RETR, 0x2F); // 750us delay, 15 retry
        nrf24_write_reg(NRF24_REG_RF_CH,      76);   // کانال ۲.۴۷۶ GHz (0-125)
        nrf24_write_reg(NRF24_REG_RF_SETUP,   0x06); // 1Mbps, 0dBm
        nrf24_write_reg(NRF24_REG_STATUS,     0x70); // پاک کردن بیت‌های IRQ
        
        /* طول پیکلود Rx/Tx (مثلاً 32 بایت) */
        nrf24_write_reg(NRF24_REG_RX_PW_P0,   32);
    }
    
    void nrf24_tx_mode(uint8_t* address, uint8_t channel)
    {
        NRF24_CE_LOW();
        nrf24_write_reg_multi(NRF24_REG_TX_ADDR,    address, 5);
        nrf24_write_reg_multi(NRF24_REG_RX_ADDR_P0, address, 5); // برای ACK
        nrf24_write_reg(NRF24_REG_RF_CH, channel);
        
        uint8_t config = nrf24_read_reg(NRF24_REG_CONFIG);
        /* PRIM_RX=0 برای ارسال */
        config &= ~(1<<0);
        nrf24_write_reg(NRF24_REG_CONFIG, config);
        
        NRF24_CE_HIGH();
        HAL_Delay(1);
    }
    
    void nrf24_rx_mode(uint8_t* address, uint8_t channel)
    {
        NRF24_CE_LOW();
        nrf24_write_reg_multi(NRF24_REG_RX_ADDR_P0, address, 5);
        nrf24_write_reg(NRF24_REG_RF_CH, channel);
        
        uint8_t config = nrf24_read_reg(NRF24_REG_CONFIG);
        config |= (1<<0);          // PRIM_RX = 1
        nrf24_write_reg(NRF24_REG_CONFIG, config);
        
        NRF24_CE_HIGH();
        HAL_Delay(1);
    }
    
    uint8_t nrf24_send(uint8_t* data, uint8_t len)
    {
        uint8_t status;
        NRF24_CSN_LOW();
        uint8_t cmd = NRF24_CMD_W_TX_PAYLOAD;
        HAL_SPI_Transmit(&NRF24_SPI, &cmd, 1, HAL_MAX_DELAY);
        HAL_SPI_Transmit(&NRF24_SPI, data, len, HAL_MAX_DELAY);
        NRF24_CSN_HIGH();
        
        /* منتظر TX_DS یا MAX_RT */
        uint32_t tickstart = HAL_GetTick();
        do {
            status = nrf24_read_reg(NRF24_REG_STATUS);
            if(status & (1<<5)) {           // TX_DS
                nrf24_write_reg(NRF24_REG_STATUS, (1<<5));
                return 1;                  // موفق
            }
            if(status & (1<<4)) {           // MAX_RT
                nrf24_write_reg(NRF24_REG_STATUS, (1<<4));
                nrf24_send_cmd(NRF24_CMD_FLUSH_TX);
                return 0;                  // شکست
            }
        } while(HAL_GetTick() - tickstart < 100);    // تایم‌اوت 100ms
        
        return 0;
    }
    
    uint8_t nrf24_is_data_available(void)
    {
        uint8_t status = nrf24_read_reg(NRF24_REG_STATUS);
        if(status & (1<<6)) {               // RX_DR
            nrf24_write_reg(NRF24_REG_STATUS, (1<<6));
            return 1;
        }
        return 0;
    }
    
    void nrf24_receive(uint8_t* data, uint8_t len)
    {
        NRF24_CSN_LOW();
        uint8_t cmd = NRF24_CMD_R_RX_PAYLOAD;
        HAL_SPI_Transmit(&NRF24_SPI, &cmd, 1, HAL_MAX_DELAY);
        HAL_SPI_Receive(&NRF24_SPI, data, len, HAL_MAX_DELAY);
        NRF24_CSN_HIGH();
        
        nrf24_send_cmd(NRF24_CMD_FLUSH_RX);  // FIFO رو خالی کن
    }
    
    /* ===== توابع خصوصی ===== */
    
    static uint8_t nrf24_read_reg(uint8_t reg)
    {
        uint8_t spiBuf[2];
        NRF24_CSN_LOW();
        spiBuf[0] = NRF24_CMD_R_REGISTER | (reg & 0x1F);
        HAL_SPI_Transmit(&NRF24_SPI, spiBuf, 1, HAL_MAX_DELAY);
        HAL_SPI_Receive(&NRF24_SPI, &spiBuf[1], 1, HAL_MAX_DELAY);
        NRF24_CSN_HIGH();
        return spiBuf[1];
    }
    
    static void nrf24_write_reg(uint8_t reg, uint8_t data)
    {
        NRF24_CSN_LOW();
        uint8_t buf[2] = { NRF24_CMD_W_REGISTER | (reg & 0x1F), data };
        HAL_SPI_Transmit(&NRF24_SPI, buf, 2, HAL_MAX_DELAY);
        NRF24_CSN_HIGH();
    }
    
    static void nrf24_write_reg_multi(uint8_t reg, uint8_t* data, uint8_t len)
    {
        NRF24_CSN_LOW();
        uint8_t cmd = NRF24_CMD_W_REGISTER | (reg & 0x1F);
        HAL_SPI_Transmit(&NRF24_SPI, &cmd, 1, HAL_MAX_DELAY);
        HAL_SPI_Transmit(&NRF24_SPI, data, len, HAL_MAX_DELAY);
        NRF24_CSN_HIGH();
    }
    
    static void nrf24_read_reg_multi(uint8_t reg, uint8_t* data, uint8_t len)
    {
        NRF24_CSN_LOW();
        uint8_t cmd = NRF24_CMD_R_REGISTER | (reg & 0x1F);
        HAL_SPI_Transmit(&NRF24_SPI, &cmd, 1, HAL_MAX_DELAY);
        HAL_SPI_Receive(&NRF24_SPI, data, len, HAL_MAX_DELAY);
        NRF24_CSN_HIGH();
    }
    
    static void nrf24_send_cmd(uint8_t cmd)
    {
        NRF24_CSN_LOW();
        HAL_SPI_Transmit(&NRF24_SPI, &cmd, 1, HAL_MAX_DELAY);
        NRF24_CSN_HIGH();
    }
    

    ۵) main.c (نمونه‌ی سادهٔ ارسال «Hello»)

    فقط بخش‌های مهم نشان داده شده است:

    #include "main.h"
    #include "nrf24.h"
    #include <string.h>
    
    uint8_t tx_address[5] = { 'A','B','C','D','E' };
    uint8_t rx_buffer[32];
    
    int main(void)
    {
      HAL_Init();
      SystemClock_Config();
      MX_GPIO_Init();
      MX_SPI1_Init();      // توسط CubeMX ساخته می‌شود
    
      nrf24_init();
      nrf24_tx_mode(tx_address, 76);   // دستگاه فعلاً نقش فرستنده دارد
    
      while (1)
      {
          char msg[] = "Hello World 123";
          if(nrf24_send((uint8_t*)msg, strlen(msg)))
          {
              HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13); // LED چشمک موفق
          }
          HAL_Delay(500);
      }
    }
    

    اگر می‌خواهید همین بُرد را در حالت گیرنده قرار دهید:

      nrf24_init();
      nrf24_rx_mode(tx_address, 76);
    
      while(1)
      {
          if(nrf24_is_data_available())
          {
              nrf24_receive(rx_buffer, 32);
              printf("RX: %s\r\n", rx_buffer);   // با UART یا SWO چاپ کنید
          }
      }
    

    ۶) تنظیم CubeMX (خلاصه)

    1. Pinout & Configuration
      • SPI1 → Mode: Full Duplex Master, 8-bit, 1 Mbps (پیش‌فرض)
      • GPIO Output → CE و CSN را Output Push-Pull بگذارید (Very High Speed).
    2. NVIC/IRQ لازم نیست مگر بخواهید از پایه‌ی IRQ استفاده کنید.
    3. Project Manager → Toolchain/IDE = STM32CubeIDE.
    4. Generate Code → پوشه‌ی Core/Inc و Core/Src را باز کنید و فایل‌ها را کپی کنید.

    ۷) فعال کردن printf برای دیباگ (اختیاری)

    اگر می‌خواهید رشته‌های دریافتی را روی UART ببینید:
    • MX_USARTx_Init را در CubeMX فعال کنید، سپس روتین __io_putchar یا retarget در syscalls.c اضافه کنید.


    ۸) نکته‌های عملی

    • nRF24L01+ نسبت به نویز حساس است؛ خازن 10 µF و 100 nF نزدیک ماژول بگذارید.
    • ولتاژ حتماً 3.3 V باشد؛ بسیاری از بُردهای آردوینویی خروجی 5 V دارند که ماژول را می‌سوزاند.
    • برای برد بیشتر از 50 m استفاده از +PA+LNA توصیه می‌شود (و تنظیم RF_SETUP روی 250 kbps).
    • اگر ارتباط برقرار نشد، ابتدا PA_PWR و RF_CH هر دو گره را بررسی کنید که یکسان باشد.
    • CubeIDE گاهی Optimization Level بالا باعث خطاهای زمان اجرا می‌شود؛ در صورت مشکل گزینه -Og را تست کنید.


    ۹) توسعه‌ی بیشتر

    ✓ فعال‌سازی وقفه‌ی IRQ برای حذف Polling و کاهش توان.
    ✓ چند Pipe هم‌زمان (برای آدرس‌های مختلف).
    ✓ رمزگذاری نرم‌افزاری (AES) روی داده‌های ارسالی.
    ✓ استفاده در RTOS (FreeRTOS Queue/Task).


    ۱۰) لایسنس

    کد فوق تحت مجوز MIT است؛ با حفظ کامنت مجاز به استفاده، تغییر و انتشار هستید. 😎

    موفق باشید و لذت ببرید! 🚀

  5. User

    کد nrf24 برای stm 32 میخوام

  6. Assistant

    در ادامه یک «کتابخانه‌ی سبک» + «نمونه برنامه‌ی فرستنده و گیرنده» برای راه‌اندازی ماژول +nRF24L01 با میکروکنترلرهای STM32 (مبتنی بر HAL) ارائه شده است.
    کد بر روی اکثر MCUهای سری F0/F1/F3/F4/G0/L0 … بدون تغییر اساسی کار می‌کند؛ کافی است فقط پایه‌های CE/CSN/IRQ و هندل SPI خود را طبق پروژه‌ی CubeMX تغییر دهید.


    1) اتصال پایه‌ها

    nRF24L01توضیحSTM32 Pin نمونه (Nucleo-F103RB)
    GNDزمینGND
    VCC (3.3V)3.0–3.6 V (جریان آنی تا 115 mA → خازن 10 µF نزدیک ماژول)3V3
    CEChip Enable (فعال‌سازی TX/RX)PA8
    CSNSPI Chip-Select (فعّال‌سازی رجیستر)PA4 (NSS دستی)
    SCKکلاک SPIPA5 (SPI1_SCK)
    MOSIداده خروجی MCU→nRFPA7 (SPI1_MOSI)
    MISOداده ورودی nRF→MCUPA6 (SPI1_MISO)
    IRQوقفه (Active-Low)PB0 (اختیاری؛ External Interrupt)

    در CubeMX:
    • SPI1 → Full Duplex Master، 8-bit، Prescaler 8 (≈8 MHz برای 72 MHz Core).
    • GPIO CE/CSN را Output push-pull.
    • در صورت نیاز IRQ را به EXTI تنظیم کنید.


    2) فایل nrf24.h

    #ifndef _NRF24_H_
    #define _NRF24_H_
    
    #include "stm32f1xx_hal.h"   // یا هدر سری MCU خودتان
    
    /* === تنظیمات پروژه شما === */
    extern SPI_HandleTypeDef hspi1;   // نام هندل SPI در CubeMX
    #define NRF24_SPI       &hspi1
    
    #define NRF24_CE_PORT   GPIOA
    #define NRF24_CE_PIN    GPIO_PIN_8
    #define NRF24_CSN_PORT  GPIOA
    #define NRF24_CSN_PIN   GPIO_PIN_4
    
    /* === ماکروهای کمکی === */
    #define CE_HIGH()  HAL_GPIO_WritePin(NRF24_CE_PORT,  NRF24_CE_PIN , GPIO_PIN_SET)
    #define CE_LOW()   HAL_GPIO_WritePin(NRF24_CE_PORT,  NRF24_CE_PIN , GPIO_PIN_RESET)
    #define CSN_HIGH() HAL_GPIO_WritePin(NRF24_CSN_PORT, NRF24_CSN_PIN, GPIO_PIN_SET)
    #define CSN_LOW()  HAL_GPIO_WritePin(NRF24_CSN_PORT, NRF24_CSN_PIN, GPIO_PIN_RESET)
    
    /* === ثوابت رجیستر === */
    #define NRF24_CMD_W_REGISTER      0x20
    #define NRF24_CMD_R_REGISTER      0x00
    #define NRF24_CMD_R_RX_PAYLOAD    0x61
    #define NRF24_CMD_W_TX_PAYLOAD    0xA0
    #define NRF24_CMD_FLUSH_TX        0xE1
    #define NRF24_CMD_FLUSH_RX        0xE2
    #define NRF24_CMD_NOP             0xFF
    
    /* رجیسترها */
    #define CONFIG      0x00
    #define EN_AA       0x01
    #define EN_RXADDR   0x02
    #define SETUP_AW    0x03
    #define SETUP_RETR  0x04
    #define RF_CH       0x05
    #define RF_SETUP    0x06
    #define STATUS_REG  0x07
    #define RX_PW_P0    0x11
    #define FIFO_STATUS 0x17
    #define DYNPD       0x1C
    #define FEATURE     0x1D
    
    /* فانکشن‌ها */
    void   nrf24_initTX(uint8_t *txAddr, uint8_t channel);
    void   nrf24_initRX(uint8_t *rxAddr, uint8_t payloadLen, uint8_t channel);
    uint8_t nrf24_sendPacket(uint8_t *data, uint8_t size);
    uint8_t nrf24_receivePacket(uint8_t *data, uint8_t *length);
    
    #endif
    

    3) فایل nrf24.c

    #include "nrf24.h"
    
    /* توابع کمکی SPI */
    static uint8_t nrf24_spiTransfer(uint8_t data)
    {
        uint8_t rx;
        HAL_SPI_TransmitReceive(NRF24_SPI, &data, &rx, 1, HAL_MAX_DELAY);
        return rx;
    }
    
    static uint8_t nrf24_readReg(uint8_t reg)
    {
        CSN_LOW();
        nrf24_spiTransfer(NRF24_CMD_R_REGISTER | (reg & 0x1F));
        uint8_t val = nrf24_spiTransfer(0xFF);
        CSN_HIGH();
        return val;
    }
    
    static void nrf24_writeReg(uint8_t reg, uint8_t val)
    {
        CSN_LOW();
        nrf24_spiTransfer(NRF24_CMD_W_REGISTER | (reg & 0x1F));
        nrf24_spiTransfer(val);
        CSN_HIGH();
    }
    
    static void nrf24_writeBuf(uint8_t reg, uint8_t *buf, uint8_t len)
    {
        CSN_LOW();
        nrf24_spiTransfer(NRF24_CMD_W_REGISTER | (reg & 0x1F));
        while (len--) nrf24_spiTransfer(*buf++);
        CSN_HIGH();
    }
    
    static void nrf24_readBuf(uint8_t reg, uint8_t *buf, uint8_t len)
    {
        CSN_LOW();
        nrf24_spiTransfer(NRF24_CMD_R_REGISTER | (reg & 0x1F));
        while (len--) *buf++ = nrf24_spiTransfer(0xFF);
        CSN_HIGH();
    }
    
    static void nrf24_cmd(uint8_t cmd)
    {
        CSN_LOW();
        nrf24_spiTransfer(cmd);
        CSN_HIGH();
    }
    
    /* === API عمومی === */
    void nrf24_initTX(uint8_t *txAddr, uint8_t channel)
    {
        CE_LOW();
        HAL_Delay(5);                    // پاورآپ ماژول
    
        nrf24_writeReg(CONFIG, 0x0E);    // PWR_UP=1, PRIM_TX=0, CRC=2byte
        nrf24_writeReg(EN_AA, 0x01);     // AutoAck روی Pipe0
        nrf24_writeReg(EN_RXADDR, 0x01); // Pipe0 فعال
        nrf24_writeReg(SETUP_AW, 0x03);  // 5 Bytes address
        nrf24_writeReg(SETUP_RETR, 0x3F);// 15 retransmit, 4000µs
        nrf24_writeReg(RF_CH, channel);  // کانال 0..125
        nrf24_writeReg(RF_SETUP, 0x06);  // 1Mbps, 0dBm
        nrf24_writeReg(STATUS_REG, 0x70);// پاک کردن فلگ‌ها
        nrf24_writeBuf(0x10, txAddr, 5); // TX_ADDR
        nrf24_writeBuf(0x0A, txAddr, 5); // RX_ADDR_P0 (برای ACK)
    
        CE_HIGH();
        HAL_Delay(2);
    }
    
    void nrf24_initRX(uint8_t *rxAddr, uint8_t payloadLen, uint8_t channel)
    {
        CE_LOW();
        HAL_Delay(5);
    
        nrf24_writeReg(CONFIG, 0x0F);      // PWR_UP=1, PRIM_RX=1
        nrf24_writeReg(EN_AA, 0x01);
        nrf24_writeReg(EN_RXADDR, 0x01);
        nrf24_writeReg(SETUP_AW, 0x03);
        nrf24_writeReg(RF_CH, channel);
        nrf24_writeReg(RF_SETUP, 0x06);
        nrf24_writeReg(RX_PW_P0, payloadLen);   // طول ثابت Payload
        nrf24_writeReg(STATUS_REG, 0x70);
        nrf24_writeBuf(0x0A, rxAddr, 5);   // RX_ADDR_P0
    
        CE_HIGH();
        HAL_Delay(2);
    }
    
    /* برمی‌گرداند: 1=ارسال OK ، 0=خطا */
    uint8_t nrf24_sendPacket(uint8_t *data, uint8_t size)
    {
        uint8_t status;
    
        CE_LOW();
        nrf24_cmd(NRF24_CMD_FLUSH_TX);
    
        CSN_LOW();
        nrf24_spiTransfer(NRF24_CMD_W_TX_PAYLOAD);
        while (size--) nrf24_spiTransfer(*data++);
        CSN_HIGH();
    
        CE_HIGH();                       // شروع ارسال
        while (1)
        {
            status = nrf24_readReg(STATUS_REG);
            if (status & 0x20) {        // TX_DS
                nrf24_writeReg(STATUS_REG, 0x20);
                break;
            }
            if (status & 0x10) {        // MAX_RT
                nrf24_writeReg(STATUS_REG, 0x10);
                nrf24_cmd(NRF24_CMD_FLUSH_TX);
                return 0;
            }
        }
        return 1;
    }
    
    /* برمی‌گرداند: 1=داده دریافت شد ، 0=چیزی نبود */
    uint8_t nrf24_receivePacket(uint8_t *data, uint8_t *length)
    {
        uint8_t status = nrf24_readReg(STATUS_REG);
        if (status & 0x40)               // RX_DR
        {
            CSN_LOW();
            nrf24_spiTransfer(NRF24_CMD_R_RX_PAYLOAD);
            uint8_t len = *length;
            while (len--) *data++ = nrf24_spiTransfer(0xFF);
            CSN_HIGH();
    
            nrf24_writeReg(STATUS_REG, 0x40);
            nrf24_cmd(NRF24_CMD_FLUSH_RX);
            return 1;
        }
        return 0;
    }
    

    4) مثال main.c (فرستنده)

    /* USER CODE BEGIN Includes */
    #include "nrf24.h"
    #include <string.h>
    /* USER CODE END Includes */
    
    int main(void)
    {
      HAL_Init();
      SystemClock_Config();
      MX_GPIO_Init();
      MX_SPI1_Init();
    
      uint8_t addr[5] = "NODE1";
      nrf24_initTX(addr, 40);      // کانال 40 ~ 2.440GHz
    
      uint32_t tick = HAL_GetTick();
    
      while (1)
      {
        if (HAL_GetTick() - tick > 1000)   // هر ثانیه
        {
          tick = HAL_GetTick();
          uint8_t msg[] = "Hello RF!";
          if (nrf24_sendPacket(msg, sizeof(msg)))
            HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13); // LED OK
        }
      }
    }
    

    5) مثال main.c (گیرنده)

    /* USER CODE BEGIN Includes */
    #include "nrf24.h"
    #include <string.h>
    /* USER CODE END Includes */
    
    int main(void)
    {
      HAL_Init();
      SystemClock_Config();
      MX_GPIO_Init();
      MX_SPI1_Init();
    
      uint8_t addr[5] = "NODE1";
      nrf24_initRX(addr, 9, 40);   // طول 9 بایت: "Hello RF!"
    
      uint8_t buf[32]; uint8_t len = 9;
    
      while (1)
      {
        if (nrf24_receivePacket(buf, &len))
        {
          /* اینجا پردازش کنید */
          HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
        }
      }
    }
    

    6) نکات مهم عیب‌یابی

    1. تغذیه پایدار 3.3 V با خازن حداقل 10 µF نزدیک ماژول.
    2. سرعت SPI حداکثر 10 MHz برای VDD=3.3 V (معمولاً 8 MHz تنظیم کنید).
    3. پس از Power-On صبر ≥5 ms قبل از دستکاری رجیسترها.
    4. کانال رادیویی (۰–۱۲۵) و آدرس Pipe باید در هر دو سمت یکسان باشد.
    5. در محیط نویزی سرعت 250 kbps (بیت RF_SETUP=0x27) برد بیشتری می‌دهد.
    6. اگر ACK نمی‌خواهید: بیت EN_AA=0 و در TX CONFIG=0x0E کافی است.
    7. از IRQ (پایین فعال) برای وقفه RX/TX استفاده کنید تا Poll نشود.

    7) توسعه بیشتر

    • فعال‌سازی Dynamic Payload (FEATURE، DYNPD) برای طول متغیر.
    • استفاده از ESB Library رسمی Nordic برای قابلیت MultiCeiver.
    • افزودن CRC 1Byte یا خاموش کردن آن برای کاهش تأخیر.
    • ترکیب با FreeRTOS: فانکشن‌های ارسال/دریافت را داخل Task و Mutex SPI قرار دهید.


    موفق باشید! 🚀
    اگر سؤالی یا مشکلی در راه‌اندازی داشتید خوشحال می‌شوم کمک کنم.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.