Программный контроллер интерфейса на STM32

Проблема обратной совместимости, вероятнее всего, будет всегда.
В области разработки электроники порой приходится поддерживать устройства 30-летней давности (а иногда и старше).
В таких аппаратах иногда всё собрано на логике, без каких-либо программируемых элементов.
Кроме того, в старой технике существуют доморощенные интерфейсы, которые не реализуются какими-либо серийно выпускаемыми контроллерами.
В таких случаях совместимые контроллеры приходится реализовывать на CPLD\FPGA\ASIC.

Я подумал, что можно обойтись без указанных выше средств, а именно реализовать контроллер интерфейса программно на микроконтроллере серии STM32F4.



Основная идея заключается в использовании связки TIM+DMA+GPIO:

-Таймер настраивается на требуемую частоту и генерирует запросы для DMA
-DMA по запросам таймера перекладывает данные из памяти в регистры GPIO
-В результате на линиях GPIO с нужной частотой выставляются нужные значения

Ограничения STM32:
-К регистрам GPIO имеет доступ только DMA2, а запросы к DMA2 умеют генерировать только TIM1 и TIM8.
-Транзакция DMA из памяти в регистры периферии или обратно занимает около 10-12 тактов шины (зависит от кучи условий, описанных в Application note AN4031).

Таким образом, максимум для данного решения — 16 линий с частотой порядка 12-14 МГц.

Для проверки жизнеспособности идеи был выбран интерфейс MIL-STD 1573 (известный у нас как МКО).

Интерфейс представляет собой дифференциальную пару с кодом Манчестер-2 — на каждый бит (занимающий 1 мкс) приходится переход сигнала из 0 в 1 либо обратно, то есть 2 уровня (значение бита определяется не уровнем сигнала, а направлением его перепада).
Данные передаются 16-битными словами + 1 бит чётности + 3 бита синхросигнала (1,5 + 1,5 бита на разных уровнях), итого 20 мкс.
Тактовая частота — 2 МГц, теоретическая полезная пропускная способность — чуть менее 1 Мбит/с (около 0,8).



Идеологически это шина Master-Slave, инициатором обмена всегда является Master, требования ко времени реакции устройств — порядка единиц микросекунд.
Обмен всегда подразумевает «Запрос — Ответ»

Ниже для наглядности показана осциллограмма обмена между устройством, имеющим отечественный МКО-контроллер с двухполярным питанием ±15 вольт, и получившимся в результате программным контроллером.
Это запрос Master'ом пакета и ответ Slave'а на данный запрос (видно только первое слово пакета и синхросигнал второго слова, за которым ещё 30 слов).



Как видно, уровни напряжения отличаются почти в 2 раза (оба укладываются в ГОСТ), но временные характеристики сигналов одинаковые. Устройства успешно «понимают» друг друга.

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

Мной была выбрана следующая конфигурация:

Передача: TIM1(2 МГц) + DMA2_Stream5_DMA_CHANNEL_6 + GPIOD->ODR (PD0 — прямой сигнал дифференциальной пары; PD1 — инверсный (можно было бы обойтись одним выходом+инвертор)).
Массив в памяти заполняется согласно протоколу МКО, затем запускается таймер+DMA, которые выпуливают массив из памяти (по одному байту) на ноги GPIO. В конце дополнительно выпуливается 0, чтобы задавить линию.

Приём: TIM8(1 Мгц) + DMA2_Stream1_DMA_CHANNEL_7 + GPIOB->IDR (PB6 — прямой сигнал дифференциальной пары; инверсный вход не используется совсем).
На ноге GPIO настраивается прерывание по изменению входного уровня (это значит, что в канале кто-то что-то начал передавать, пора начинать слушать).
По срабатыванию прерывания запускается таймер+DMA (на максимально возможную длину пакета в МКО), которые собирают с ноги GPIO уровни (по одному байту) в массив в памяти. Массив позднее анализируется.

Для приёма также введён вспомогательный таймер TIM2 (1/20 МГц — соответствует длительности одного слова в МКО).
Он используется для обработки первого принятого из канала слова (по которому принимается решение, прекращать ли приём и выходить в передачу, или же принимать пакет дальше).
Если после анализа первого слова приём продолжился, этот же таймер останавливает таймер+DMA после приёма количества слов, указанного в первом принятом слове.
Также, после срабатывания этого таймера пуляется ответное слово (или целый ответный пакет)

После приёма данных и остановки таймера+DMA выставляется packet_received_length, который означает, что есть принятые данные и их надо распарсить и отправить наверх.

На время передачи приём отключается (прерывание на ноге-уловителе отключено)

Примерно прикинув архитектуру, я взялся за реализацию.

Поскольку я буду работать с регистрами GPIO по одному байту, а полезных там 1 или 2 бита, мне нужно уметь преобразовывать полезные данные в то, что будет передано с помощью DMA в GPIO, и обратно.
Сначала мне потребовалось немножко макросов для удобной работы с форматом слов в МКО:

#define MKO_RX_GPIO_OFFSET  6 //PB6
#define MKO_RX_1  (long long)(1 << MKO_RX_GPIO_OFFSET)
#define MKO_RX_BYTE_MASK  ((MKO_RX_1 << 56) + (MKO_RX_1 << 48) + (MKO_RX_1 << 40) + (MKO_RX_1 << 32) + (MKO_RX_1 << 24) + (MKO_RX_1 << 16) + (MKO_RX_1 << 8) + MKO_RX_1)

#define MKO_LOW   (long long)(2)
#define MKO_HIGH  (long long)(1)

#define MKO_0 ((MKO_HIGH << 8) + MKO_LOW)
#define MKO_1 ((MKO_LOW << 8) + MKO_HIGH)

#define MKO_0x0 ((MKO_0 << 48) + (MKO_0 << 32) + (MKO_0 << 16) + MKO_0)
#define MKO_0x1 ((MKO_1 << 48) + (MKO_0 << 32) + (MKO_0 << 16) + MKO_0)
.
.
#define MKO_0xF ((MKO_1 << 48) + (MKO_1 << 32) + (MKO_1 << 16) + MKO_1)

#define CMD_ACK_WORD  ((MKO_LOW << 56) + (MKO_LOW << 48) + (MKO_LOW << 40) + (MKO_HIGH << 32) + (MKO_HIGH << 24) + (MKO_HIGH << 16))
#define DATA_WORD     ((MKO_HIGH << 56) + (MKO_HIGH << 48) + (MKO_HIGH << 40) + (MKO_LOW << 32) + (MKO_LOW << 24) + (MKO_LOW << 16))

const unsigned long long mko_tetrades[16] = {MKO_0x0, MKO_0x1, MKO_0x2, MKO_0x3, MKO_0x4, MKO_0x5, MKO_0x6, MKO_0x7, MKO_0x8, MKO_0x9, MKO_0xA, MKO_0xB, MKO_0xC, MKO_0xD, MKO_0xE, MKO_0xF};

Также мне нужны были функции упаковки\распаковки данных:

void short_to_mko(unsigned char* data, unsigned int start_pos, unsigned int command_word, unsigned int input_data)
{
  if (command_word)
    *(long long*)&data[start_pos] |= CMD_ACK_WORD;
  else
    *(long long*)&data[start_pos] |= DATA_WORD;

  *(long long *)&data[start_pos +  8] = mko_tetrades[(input_data >> 12) & 0xf];
  *(long long *)&data[start_pos + 16] = mko_tetrades[(input_data >> 8) & 0xf];
  *(long long *)&data[start_pos + 24] = mko_tetrades[(input_data >> 4) & 0xf];
  *(long long *)&data[start_pos + 32] = mko_tetrades[(input_data >> 0) & 0xf];

  input_data -= (input_data >> 1) & 0x5555;
  input_data = ((input_data >> 2) & 0x3333) + (input_data & 0x3333);
  input_data = ((input_data >> 4) + input_data) & 0x0f0f;
  input_data = ((input_data >> 8) + input_data) & 0x00ff;
    
  if (input_data & 1)
    *(unsigned int*)&data[start_pos + 40] = MKO_0;
  else
    *(unsigned int*)&data[start_pos + 40] = MKO_1;
}

unsigned int mko_to_short(unsigned char* data, unsigned int start_pos)
{
  unsigned int output_data;
  long long byte;
  unsigned int crc;
  
  byte = (*(long long *)&data[start_pos]) & MKO_RX_BYTE_MASK;
  output_data = MKO_RX_BYTE_PACK(byte);
  output_data <<= 8;
  byte = (*(long long *)&data[start_pos + 8]) & MKO_RX_BYTE_MASK;
  output_data |= MKO_RX_BYTE_PACK(byte) & 0xff;
  crc = output_data & 0xffff;
  
  crc -= (crc >> 1) & 0x5555;
  crc = ((crc >> 2) & 0x3333) + (crc & 0x3333);
  crc = ((crc >> 4) + crc) & 0x0f0f;
  crc = ((crc >> 8) + crc) & 0x00ff;
  
  if ((crc & 1) == (data[start_pos + 16] >> MKO_RX_GPIO_OFFSET))
    packet_error = 1;
  
  return output_data & 0xffff;
}

Теперь можно браться непосредственно за контроллерную часть.

Уловитель фронта принимаемого сигнала, зарядка приёмного DMA и таймера TIM2 (вспомогательного, для определения количества принятого)

void mko_start_receive()
{
  unsigned int i;
  
  (EXTI->IMR) &= (~RX_START_INT);//выключаем прерывание (не ловим, если уже поймали (включим после окончания приёма)
      
  //заряжаем DMA на приём максимально возможной последовательности (если надо - потом на лету остановим в прерывании таймера TIM2)
  htim8.hdma[TIM_DMA_ID_UPDATE]->Instance->NDTR = 660;
  htim8.hdma[TIM_DMA_ID_UPDATE]->Instance->CR |= DMA_IT_TC;
  htim8.hdma[TIM_DMA_ID_UPDATE]->Instance->CR |= DMA_SxCR_EN;

  i = 50;
  while(i--);//сдвигаем запуск DMA более чем на 1 период (около 1.5 мкс)

  TIM8->CNT = 80;//калибровка (внутри одного периода) приёмного DMA (куда попадают отсчёты - сейчас на 250 нс (середина отсчёта))

  __HAL_TIM_ENABLE_DMA(&htim8, TIM_DMA_UPDATE);
  __HAL_TIM_ENABLE(&htim8);
   
  TIM2->SR = 0;//дабы не генерировалось прерывание сразу после запуска таймера
  TIM2->ARR = 1400 - 1;//заряжаем таймер на 20 мкс (1 слово) (чтобы проанализировать первое приянтое и решить, что делать далее)
  TIM2->CNT = 0;
  HAL_TIM_Base_Start_IT(&htim2);//заряжаем на 20 мкс (1 слово)
  
}

void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
{  
  /* EXTI line interrupt detected */
  if(__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != RESET)
  {
    __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);
    
    if ((GPIO_Pin == GPIO_PIN_6) && ((GPIOB->IDR) & GPIO_PIN_6))
      mko_start_receive();

  }
}

Вторая проверка состояния пина добавлена в качестве антидребезга.
Волшебные константы — результаты калибровки приёмного таймера+DMA (об этом ниже).

Далее функция запуска и настройки приёмного и передающего DMA, в том числе задание конечного адреса GPIO (сейчас GPIOB и GPIOD)

HAL_StatusTypeDef HAL_TIM_Base_Start_DMA(TIM_HandleTypeDef *htim, uint32_t *pData, uint16_t Length)
{
  
  if((htim->State == HAL_TIM_STATE_BUSY))
     return HAL_BUSY;
  else if((htim->State == HAL_TIM_STATE_READY))
  {
    if((pData == 0U) && (Length > 0U)) 
      return HAL_ERROR;                                    
    else
      htim->State = HAL_TIM_STATE_BUSY;
  }  

  htim->hdma[TIM_DMA_ID_UPDATE]->XferCpltCallback = TIM_DMAPeriodElapsedCplt;
  htim->hdma[TIM_DMA_ID_UPDATE]->XferErrorCallback = TIM_DMAError ;

  
  if (htim->Instance == TIM1)
    HAL_DMA_Start_IT(htim->hdma[TIM_DMA_ID_UPDATE], (uint32_t)pData, (uint32_t)&(GPIOD->ODR), Length);
  
  if (htim->Instance == TIM8)
  {
#ifdef RX_CALIB
    HAL_DMA_Start_IT(htim->hdma[TIM_DMA_ID_UPDATE], (uint32_t)pData, (uint32_t)&(GPIOB->ODR), Length);
#else
    HAL_DMA_Start_IT(htim->hdma[TIM_DMA_ID_UPDATE], (uint32_t)&(GPIOB->IDR), (uint32_t)pData, Length);
#endif
  }
    
  __HAL_TIM_ENABLE_DMA(htim, TIM_DMA_UPDATE);
  __HAL_TIM_ENABLE(htim);  
  return HAL_OK;
}

Макрос RX_CALIB я завёл для того, чтобы откалибровать приёмный таймер+DMA, а именно для того, чтобы видеть куда приходятся выборки на входном сигнале (в идеале они должны попадать на середину бита).

Теперь основная логика МКО: анализ первого принятого слова, затем ответ либо зарядка на приём остального; ответ после приёма остального и выставление packet_received_length

void mko_slave_receive(void)
{
  register unsigned int data;
  register unsigned int i;
  static unsigned int first = 1;
  static unsigned int mko_data_length;
  
  data = mko_to_short(&in_arr[0] ,0);
    
  if (first)//если это первое срабатывание таймера - анализируем первое принятое слово и решаем, что делать далее
  {
    if (!packet_error)
    {
      if (data & MASTER_DATA_REQUEST)//значит надо останавливать приём отвечать
      {
        first = 1;
        HAL_TIM_Base_Stop_IT(&htim2);
        HAL_TIM_Base_Stop_DMA(&htim8);
        htim8.hdma[TIM_DMA_ID_UPDATE]->Instance->CR &= ~DMA_SxCR_EN;      
            
        mko_send((unsigned char*)&out_arr[i][0], out_array_data_length[i]);//после того, как отработает передающий DMA, прерывание на уловителе будет включено заново
        
        memcpy(in_arr_copy, in_arr, IN_ARRAY_LENGTH);
#ifndef RX_CALIB //дабы не затереть in_arr, где при калибровке лежит выходной меандр
        memset(in_arr, 0, IN_ARRAY_LENGTH);//это занимает около 4 мкс, гипотетически можно убрать
#endif
        
        packet_received_length = 1;
        
      }
      else//надо продолжать приём, зарядив таймер на нужное количество слов
      {
        first = 0;
        data = data & 0x1F;
        if (!data)
          data = 32;
        TIM2->ARR = (data * 1680) - 1;
        mko_data_length = data;
      }
    }
    else
    {
      packet_received_length = 1;//считаем, что приняли одно слово и оно с ошибкой
      HAL_TIM_Base_Stop_IT(&htim2);
      HAL_TIM_Base_Stop_DMA(&htim8);
      htim8.hdma[TIM_DMA_ID_UPDATE]->Instance->CR &= ~DMA_SxCR_EN;
      EXTI->IMR |= RX_START_INT;//enable interrupt - ловим следующий
    }
  }
  else//если второе срабатывание - значит приняли весь пакет, надо пулять ответное слово и анализировать данные (ставим флаг packet_received_length)
  {
    first = 1;
    HAL_TIM_Base_Stop_IT(&htim2);
    HAL_TIM_Base_Stop_DMA(&htim8);
    htim8.hdma[TIM_DMA_ID_UPDATE]->Instance->CR &= ~DMA_SxCR_EN;   
            
    mko_send((unsigned char*)&out_arr[i][0], out_array_data_length[i]);//после того, как отработает передающий DMA, прерывание на уловителе будет включено заново
    
    memcpy(in_arr_copy, in_arr, IN_ARRAY_LENGTH);
#ifndef RX_CALIB //дабы не затереть in_arr, где при калибровке лежит выходной меандр
    memset(in_arr, 0, IN_ARRAY_LENGTH);//это занимает около 4 мкс, гипотетически можно убрать
#endif
      
    packet_received_length = mko_data_length;
    
  }
}



void TIM2_IRQHandler(void)
{
  if (interface == INTERFACE_MKO_SLAVE)//в МКО ОУ если сработал этот таймер - принято слово (или целый пакет)
    mko_slave_receive();
  else if (interface == INTERFACE_MKO_MASTER)//в МКО КШ если сработал этот таймер - принято слово (или целый пакет)
    mko_master_receive();
  
  TIM2->SR = ~(TIM_IT_UPDATE);
  HAL_NVIC_ClearPendingIRQ(TIM2_IRQn);
}

Код приведён в сжатом виде, полный проект представляет собой преобразователь MKO-Ethernet с кучей дополнительного функционала.
Однако приведённого описания и кода достаточно для понимания сути идеи.
Да, я реализовал минимальную логику, в ГОСТе на МКО описано гораздо больше.
Однако для обратной совместимости с конкретным устройством этого оказалось достаточно.
По факту проект оказался вполне успешным, контроллер полностью справляется с возложенными функциями как в режиме Master, так и Slave.

Итого, если требуется обеспечить совместимость с чем-то древним/нестандартным, необязательно привлекать плисовода. В зачительном количестве случаев можно обойтись и программной реализацией контроллера.