Почему Serial.write() медленнее, чем memcpy()?

Я использую Serial.write() для передачи 53 байтов на ПК. Для измерения времени я использую micros() (до и после функции записи). После каждой передачи существует задержка в 1 с.

Время функции Serial.write() составляет 532 мкс при скорости 1000000 бод и 360 мкс при скорости 9600 бод.

Функция Serial.write() явно асинхронна, поскольку передача 53 байтов со скоростью 9600 бод составляет 53*8/9600*1e6 = 44167 мкс. (Кстати, в случае со скоростью 1000000 бод не так очевидно, что функция асинхронная.)

Я использую Serial.availableForWrite() перед Serial.write(), чтобы подтвердить, что в буфере достаточно места (это возвращает 63 каждый раз, размер буфера по умолчанию 64).

Я не понимаю эти цифры. Использование memcpy() для копирования 53 байтов занимает всего 32 мкс. Копирование в последовательный буфер не совпадает с функцией memcpy()? И почему разница во времени копирования при разной скорости передачи? Согласно результатам, Serial.write() работает еще медленнее с более высокими скоростями передачи данных. Почему Serial.availableForWrite() возвращает 63, в то время как размер буфера равен 64 (согласно SERIAL_TX_BUFFER_SIZE)?

Обновление: Спасибо за все ваши ответы.

Я попробовал другую библиотеку для последовательной связи: https://github.com/greiman/SerialPort

Кажется, он быстрее оригинала. Я использую 2 измерения времени и задержку в коде, эти 3 deltaTimes представляют весь шаг следующим образом:

writeTime + memcpyTime + delaymicros = вычисленное время != реальное время

Первые 2 раза измеряются, delaymicros — это теоретическая задержка (900 мкс), по ним я могу вычислить время шага. Это вычисленное время шага отличается от реального времени (измеренное время шага, я также измеряю весь шаг). Кажется, дополнительное время можно найти в задержке.

Библиотека последовательного порта: 100 + 30 + 900 = 1030 != 1350

writeReal = 100 + 1350 - 1030 = 430

Серийный номер Arduino: 570 + 30 + 900 = 1500 != 1520

writeReal = 570 + 1520 - 1500 = 590

Затем я измерил время delaymicros (теоретически оно составляет 900 мкс), недостающее время можно найти там. Я запрограммировал задержку 900 мкс, но реальная задержка была около 1200 в первом тесте и 920 во втором тесте.

Эти измерения могут подтвердить наличие прерываний, поскольку измерение только функций записи не дает всего времени записи (особенно с загруженной последовательной библиотекой). Загруженная библиотека может работать быстрее, но требует большего буфера tx из-за ошибок (256 работает правильно вместо 64).

Вот код: я использую контрольную сумму в функции отправки (что составляет 570-532 = 38 мкс). Я использую Simulink для получения и обработки данных.

struct sendMsg1 {
  byte errorCheck;//1

  unsigned long dT1;//4
  unsigned long dT2;//4
  unsigned long t;//4
  unsigned long plus[10];//40
};//53

sendMsg1 msg1;
byte copyMsg1[53];

unsigned long time1;
unsigned long time2;
unsigned long time3;
unsigned long time4;

void setup() {
  Serial.begin(1000000);
}

void loop() {
  sensorRead();
  sendMsg1_f();

  //time3 = micros();
  delayMicroseconds(900);
  //time4 = micros();
}

void sensorRead() {
  time3 = micros();

  msg1.t = micros();
  for (unsigned long i = 0; i < 1; i++) {
    memcpy((void*)&(copyMsg1[i*sizeof(sendMsg1)]), (void*)&msg1, sizeof(sendMsg1));
  }

  time4 = micros();
  msg1.dT2 = time4 - time3;
}

void sendMsg1_f() {
  time1 = micros();

  msg1.errorCheck = 0;
  for (int i = 0; i < sizeof(sendMsg1) - 1; i++) {
    msg1.errorCheck += ((byte*)&msg1)[i];
  }
  Serial.write((byte*)&msg1,sizeof(sendMsg1));

  time2 = micros();
  msg1.dT1 = time2 - time1;
}