Qt读取串口数据：代码可运行但需提升可靠性

Hey there! Let's figure out how to make your Arduino-to-Qt PC data transfer way more reliable. First, let's tidy up and complete the code snippet you shared (since it cut off mid-line) to get a clearer picture of your current setup, then dive into practical, actionable improvements.

Current Workflow & Completed Code Snippet #

Your existing setup follows this flow:

• Wait for a trigger signal from the PC
• Collect thousands of 16-bit sensor samples (1kHz sampling rate)
• Store the data in an SRAM chip
• Transfer the stored data to the PC

Here's a completed version of your transfer code (filling in the missing SRAM read and serial send logic based on typical implementations):

void loop(){ 
  // 等待PC的触发信号，随后开始数据采集
  while (!Serial.available()) {
    // Idle until we get the trigger command from PC
  }
  Serial.read(); // Clear the trigger byte from the buffer

  // 从传感器采集数据，通常为数千个16位数值
  // 采样率1kHz，数据存储于SRAM芯片
  collectAndStoreDataToSRAM(); // Assume this function handles sampling + SRAM write

  // 以下代码实现向PC传输数据
  unsigned int datalength = getStoredSampleCount(); // Get actual number of 16-bit samples
  for(unsigned int i=0;i<datalength;i++){ 
    // 从SRAM读取16位数据
    digitalWrite(SRAM_CS, LOW);
    SPI.transfer(0x03); // Send SRAM read command
    SPI.transfer((i >> 8) & 0xFF); // High byte of SRAM address
    SPI.transfer(i & 0xFF); // Low byte of SRAM address
    byte msb = SPI.transfer(0x00);
    byte lsb = SPI.transfer(0x00);
    digitalWrite(SRAM_CS, HIGH);

    // Combine to 16-bit sample
    uint16_t sensorSample = (msb << 8) | lsb;

    // Send raw bytes to PC via serial
    Serial.write(msb);
    Serial.write(lsb);
  }
}

Key Reliability Improvements #

Raw byte streams like your current setup are prone to sync errors, missing data, or corruption. Here's how to fix that:

1. Use a Packetized Data Protocol #

Wrap your data in a structured packet so the Qt PC can verify integrity and sync correctly. A simple packet structure could be:

• Start Marker: Fixed 2-byte sequence (e.g., 0xAA 0xBB) to signal the start of a new data batch
• Data Length: 2 bytes to tell the PC exactly how many samples to expect
• Payload: All 16-bit samples (2 bytes each)
• Checksum: 2-byte CRC16 to verify no data was corrupted in transit

Example Arduino code for packetized transmission:

// Send start marker
Serial.write(0xAA);
Serial.write(0xBB);
// Send total sample count (2 bytes)
Serial.write((datalength >> 8) & 0xFF);
Serial.write(datalength & 0xFF);

uint16_t crc = 0;
for(unsigned int i=0;i<datalength;i++){ 
  // Read sample from SRAM (same as before)
  digitalWrite(SRAM_CS, LOW);
  SPI.transfer(0x03);
  SPI.transfer((i >> 8) & 0xFF);
  SPI.transfer(i & 0xFF);
  byte msb = SPI.transfer(0x00);
  byte lsb = SPI.transfer(0x00);
  digitalWrite(SRAM_CS, HIGH);

  // Update CRC with sample bytes
  crc = updateCRC16(crc, msb);
  crc = updateCRC16(crc, lsb);

  // Send sample to PC
  Serial.write(msb);
  Serial.write(lsb);
}
// Send final CRC for verification
Serial.write((crc >> 8) & 0xFF);
Serial.write(crc & 0xFF);

2. Add Handshaking Between Arduino & PC #

Blindly sending data leaves no way to confirm the PC received it correctly. Implement ACK/NACK signals:

• After Arduino sends the packet header + length, wait for a PC ACK (0x01) before sending the payload
• If no ACK arrives within a 500ms timeout, re-send the header
• After sending the full payload + CRC, wait for a PC verification ACK; if you get a NACK (0x00), re-transmit the entire packet

3. Optimize Serial Port Settings #

• Use a higher baud rate (e.g., 115200 or 230400) to reduce transfer time—fewer seconds of transmission means fewer chances of errors
• Enable hardware flow control (RTS/CTS) if your Arduino and PC support it—this prevents buffer overflow by letting the device pause transmission if the receiver's buffer is full
• Increase serial buffer sizes:
  • On Arduino: Use Serial.setTxBufferSize(1024) to handle larger batches of data at once
  • On Qt: Configure the serial port with a larger read buffer to avoid dropping bytes

4. Validate SRAM Data Before Transfer #

Before sending data to the PC, confirm it's valid:

• After collecting samples, read back a few random entries from SRAM and compare them to the original sensor data (if possible)
• Store a CRC of the collected data in SRAM alongside the samples, then verify it before initiating transfer

5. Qt Side Matching Logic #

On the PC side, make sure your Qt code:

• Listens for the 0xAA 0xBB start marker to sync with the Arduino's data stream
• Calculates the CRC16 independently and compares it to the received CRC
• Sends ACK/NACK signals promptly
• Handles timeouts gracefully (e.g., request a re-transmit if no data arrives after 2 seconds)

Quick CRC16 Implementation for Arduino #

Here's a lightweight CRC16 function you can drop into your code:

uint16_t updateCRC16(uint16_t crc, byte data) {
  crc ^= data;
  for (int i = 0; i < 8; i++) {
    if (crc & 0x0001) {
      crc = (crc >> 1) ^ 0xA001;
    } else {
      crc >>= 1;
    }
  }
  return crc;
}

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