Arduino — автоматическое определение скорости на входящем SoftwareSerial порте

562e958ec13484d95f47b2b980bfa2aa.jpg

Привет Хабр!

На днях мне необходимо было создать прототип некого простого устройства, выполняющего функционал преобразования <данные удалены>. В целом ничего особенного, однако была одна особенность, без которой данной статьи бы не было. Но обо всем по порядку, а для начала дисклеймер:
Я знаю что мой код далеко не идеален и я не претендую на звание идеального решения проблемы. Я просто делюсь своим вариантом решения данного вопроса. И вообще я МухоЖук. Вы сами во всем виноваты. Хой!

Итак, для базы прототипа был выбран Arduino Uno R3. Быстро, достаточно мощно для задачи, а главное дешево.

Суть задачи — имеется некоторое устройство, которое отправляет по UART некоторые данные, которые необходимо принять на прототипируемом устройстве и далее <данные удалены>.
Но есть одна загвоздка — Baud Rate отправляемого устройства может быть отконфигурирован по разному, а нам нужен более менее универсальный вариант. А значит необходимо определить подходящий Baud Rate.

К сожалению, Ардуино не умеет автоматически определять скорость порта, и более того, его нужно изначально задавать при инициализации интерфейса в секции setup (). Быстрое гугление данного вопроса не дало результатов, что и стало причиной написания данной статьи. Будем решать проблему самостоятельно. Для этого напишем рекурсивную функцию, которая будет инициализировать интерфейс с разной скоростью и проверять на ней входящие данные.

В моем случае входящие данные — это всегда печатаемые символы. По этому для определения «правильности» скорости я буду использовать функцию isPrintable (); которая возвращает нам true, символ является печатаемым. Вы же можете использовать другую функцию или написать свою =)

Начнем. Для начала, произведем необходимые настройки и инициализации:

#include 
//Настройки
//Пины comIn
const int RX1 = 4;
const int TX1 = 5;
//Возможные скорости для ComIn порта
long baudRates[] = {1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200};
int numBaudRates = sizeof(baudRates) / sizeof(long);
//Количество символов для проверки скорости ComIn порта
const int numCharsForSetup = 5;
//Количество циклов проверки скорости перед перезагрузкой контроллера
const int numAttemptsBeforeReset = 10;
//Конец настроек
//Счетчик попыток
int attempts = 0;
//Обьявляем софтпорт
SoftwareSerial comIn(RX1, TX1);

На этом предварительные настройки закончены, переходим в секцию setup:

void setup() {
Serial.begin(9600); //запуск "железного" порта для дебага
delay(100); //Задержка для стабилизации интерфейса
Serial.println("Init start"); //Пишем в дебаг консоль
delay(500); //Задержка для удобства дебага, в принципе её можно удалить
//инициализация пинов
pinMode(RX1, INPUT);
pinMode(TX1, OUTPUT);
initComInIface(); //наша функция запуска входящего софтпорта
Serial.println("COM IN STARTED");
delay(500); //задержка для стабилизации интерфейса и удобства дебага
Serial.println("Init end. Starting main program.");
} 

А теперь ныряем вглубь.

Забегу немного вперед — нам понадобится функция софтварного перезапуска Ардуинки, так как в процессе тестирования оказалось, что Ардуинка имеет свойство «зависать» в процессе рекурсии. Не знаю с чем это связано (кто знает почему? ), возможно с тем что у нее начинает переполняться (или наоборот, течь) память, но в любом случае софтварный перезапуск контроллера решает эту проблему:

// сброс микроконтроллера путем рестарта прошивки
void reset() {
  asm volatile("jmp 0x00");
}

И вот она рекурсивная функция. Суть ее довольно проста. Мы поочередно перебираем предполагаемые скорости, инициализируем интерфейс и вызываем функцию checkPrintable (); которая проверяет данные на интерфейсе и возвращает true, если данные соответствуют условию. Далее идет счетчик попыток — если мы сделали рекурсию большее число раз, чем указано в переменной numAttemptsBeforeReset — то мы перезагружаем ардуинку. Ну, а дальше сама рекурсия в зависимости от флага looping.

//рекурсия в ожидании определения скорости входящего софтпорта
void initComInIface() {
  bool looping = true; //флаг рекурсии
  for (int i = 0; i < numBaudRates; i++) { //цикл перебора скоростей
    comIn.begin(baudRates[i]); //запуск порта на заданной скорости
    delay(500); // задержка для стабилизации порта
    Serial.println("Trying speed " + String(baudRates[i])); //пишем в дебаг
    if (checkPrintable()) { //проверка на печатаемые символы
      Serial.println("Printable characters found at baud rate: " + String(baudRates[i])); //Если найдены печатаемые символы - пишем в дебаг
      looping = false; //останавливаем рекурсию
      break; //выходим из цикла
    } else {
      Serial.println("No printable characters found at " + String(baudRates[i])); //Просто пишем в дебаг
    }
  }
  attempts++; //увеличиваем счетчик количества попыток
  if (attempts >= numAttemptsBeforeReset && lopping == true) { //если количество попыток превысило максимальное значение и мы все еще не нашли ничего
    Serial.println("Num of attempts is more than requered. Restarting controller at 5 sec.");
    delay(5000); //здесь тоже для удобства
    reset(); //софтварная перезагрузка контроллера
  }
  if (looping) { //если флаг рекурсии все еще активен
    comIn.end(); //закрываем интерфейс
    delay(500); //задержка для стабилизации порта и удобства отслеживания
    initComInIface(); //рекурсия!
  }
}

И наконец, гвоздь программы — функция checkPrintable (); Логика в том, что мы читаем пришедшие байты несколько раз в цикле. Количество циклов определяется переменной numCharsForSetup. Если оно равно 5 — это значит что все прочитанные 5 байт должны быть печатаемыми символами. Это сделано для того, что некоторые символы могут правильно определяться на неправильных скоростях. Тестирование показало, что буква «j» одинаково верно определяется на скоростях 4800 и 9600, а символ »$» периодически одинаково определяется на скоростях 38400 и 115200. Чтение байт подряд решает данную проблему, при условие что пришедшие байты хоть немного отличаются друг от друга.

//функция проверяет, что символы приходящие на интерфейс - печаемые
boolean checkPrintable() { 
  int j = 0; //счетчик прочитаных символов
  if (comIn.available()) { //если интерфейс доступен
    for (int i = 0; i < numCharsForSetup; i++) { //цикл, проверяющий символы
      delay(100); //задержка для стабилизации. Без нее иногда происходит пропуск символа
      char c = comIn.read(); //читаем пришедший байт
      Serial.println(String(c)); //пишем его в дебаг

      if (isPrintable(c)) { //если данный байт является печатаемым символом
        j++; //добавляем в счетчик символов
        Serial.println("Found char \"" + String(c) + "\" at comIn interface. Setup of ring " + String(j) );//Снова пишем в дебаг
        delay(100); //Небольшая задержка для стабилизации. Без нее стабильно не работает
      }
      c = NULL; //Обнуляем значение переменной - данная строка повышает стабильность работы. 
    }
    if (j == numCharsForSetup) { //Если пройдены все циклы проверок
      return true;
    }
  }
  return false;
}

Да. У этого кода есть недостатки. И самый главный — мы в любом случае должны предположить используемые скорости и прописать их в программе. По этой причине мы не сможем определить не предполагаемые скорости. Но я не считаю это существенным недостатком — список скоростей стандартен, по этому мы можем их смело предполагать.
Второй недостаток — необходимость использовать множество delay. Вероятно можно обойтись и без них, но у меня не получилось.
Третий недостаток — это размер скетча. Скомпилированный код занимает чуть меньше 8 килобайт, что довольно много для ардуино уно с его 32 кб. памяти
Ну и четвертый, как по мне — самый несущественный недостаток — сама логика работы. Множество циклов, цикл в цикле, рекурсия… По моему мнению — данный код дает неслабую нагрузку на ардуинку, хотя это все относительно и вообще я могу ошибаться. Вы еще помните что я мухожук?

В целом, на этом все, всем спасибо!

© Habrahabr.ru