Программный контроллер интерфейса на 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.
Итого, если требуется обеспечить совместимость с чем-то древним/нестандартным, необязательно привлекать плисовода. В зачительном количестве случаев можно обойтись и программной реализацией контроллера.
