如何验证Quectel M66识别STM32 UART命令？乱码问题求助

Hey there, let's work through this garbled response issue you're seeing with your STM32F103C8 and Quectel M66 setup. I've tackled similar UART communication glitches before, so here are targeted steps to diagnose and fix the problem:

1. Verify UART Parameter Consistency #

Even though you've set the baud rate to 9600, don't overlook other critical UART settings—any mismatch will almost certainly cause garbled data:

• Data bits: Quectel M66 defaults to 8 bits
• Parity: No parity (N)
• Stop bits: 1 stop bit
  Double-check these in CubeMX for UART2 to ensure full alignment with the module's default configuration.

2. Rule Out Hardware Issues #

Hardware misconfigurations are a top culprit for UART communication errors:

• Cross-check wiring: Ensure STM32 UART2_TX is connected to M66's RX, and UART2_RX is connected to M66's TX. A reversed TX/RX pair will lead to unreadable responses.
• Level matching: STM32 uses 3.3V TTL levels. Confirm the M66's UART interface is also TTL (most modules are, but double-check the datasheet). If it's RS232, you'll need a level converter like MAX3232.
• Proper grounding: Make sure the STM32 and M66 share a common ground. Poor grounding can introduce noise that corrupts UART signals.

3. Fix Flaws in the Receive Logic #

Your current code has a few gaps that could lead to incomplete or garbled data:

• Uninitialized buffer: The rec_buffer allocated with malloc contains random "dirty" data. Always initialize it with memset before receiving.
• Blocking receive limitations: HAL_UART_Receive with a fixed length (50) and short timeout (200ms) might not capture the full response, especially if the module sends data in chunks.
• Memory leak: You never free the allocated rec_buffer, which will cause memory issues over time.

Here's an improved version of your code that addresses these problems:

#include <string.h>
#include <stdlib.h>

void M66_Check() { 
    char *buffer = "ATI\r\n"; 
    char *rec_buffer = (char*)malloc(200 * sizeof(char)); 
    
    // Check if memory allocation succeeded
    if(rec_buffer == NULL) {
        printf("Memory allocation failed\r\n");
        return;
    }
    
    // Initialize buffer to avoid dirty data
    memset(rec_buffer, 0, 200 * sizeof(char));

    if(HAL_UART_Transmit(&huart2, (uint8_t*)buffer, strlen(buffer), 1000) == HAL_OK) { 
        printf("AT Command sent successfully\r\n"); 
        HAL_Delay(500); // Shorten delay to match typical module response time
    } else { 
        printf("Not Sent\r\n"); 
        free(rec_buffer); // Clean up memory before exiting
        return;
    } 

    // Receive data until timeout or end of response (\r\n)
    uint32_t timeout = HAL_GetTick() + 2000;
    uint16_t rec_len = 0;
    while(HAL_GetTick() < timeout && rec_len < 199) { // Leave 1 byte for null terminator
        if(HAL_UART_Receive(&huart2, (uint8_t*)&rec_buffer[rec_len], 1, 100) == HAL_OK) {
            rec_len++;
            // Stop receiving once we get the end-of-response marker
            if(rec_len >= 2 && rec_buffer[rec_len-2] == '\r' && rec_buffer[rec_len-1] == '\n') {
                break;
            }
        }
    }

    printf("About to print Response from M66 \r\n"); 
    printf("Received %d bytes:\r\n", rec_len);
    printf("%s", rec_buffer); 
    
    free(rec_buffer); // Always free allocated memory
}

4. Additional Debug Steps #

• Test the module directly: Use a USB-to-TTL adapter to connect the M66 to your PC, send ATI\r\n via a serial terminal (like PuTTY). If the response is still garbled, the issue might be with the module itself (e.g., incorrect baud rate setting stored in the module).
• Validate STM32's transmission: Redirect STM32's UART2_TX to a PC serial terminal. Send the ATI\r\n command and confirm it's transmitted correctly (no garbled characters).

内容的提问来源于stack exchange，提问作者Vignesh