Обработка ошибок can на stm32

Один из немаловажных аспектов работы CAN шины является обработка прерываний bxCan. Их не так уж и много, но при правильной их настройке и обработке мы сможем обеспечить максимальную работоспособность и высокую отказоустойчивость нашего устройства. Поэтому следует обратить наше внимание на то, как это сделать правильно — создать необходимый минимум.

Теория

Начнем опять с теории и обратимся к Reference Maanual от ST Microelectronics.

Для начала мы попытаемся разобраться с механизмом прерываний микроконтроллера STM32F103C6, затем пройдемся по регистрам контроллера и, затем, выстроим некий шаблон, который мы сможем использовать в своих проектах.

Прерывания

Для bxCan может быть назначено четыре прерывания. Каждый из источников прерываний может быть включен или выключен независимо друг от друга в регистре CAN_IER (CAN Interrupt Enable Register).

Вот схема отработки прерываний приведенная в мануале:

Рис. 1. Флаги событий и формирование прерываний

Как видим на рисунке 1, прерывания сгруппированы в четыре группы:

• Transmit interrupt  (Прерывание при передаче сообщения) — может быть вызвано следующими событиями:

— Выполнена передача и освобожден mailbox 0. Бит RQCP0 в регистре CAN_TSR установлен;
— Выполнена передача и освобожден mailbox 1. Бит RQCP1 в регистре CAN_TSR установлен;
— Выполнена передача и освобожден mailbox 2. Бит RQCP2 в регистре CAN_TSR установлен.

• FIFO0 interrupt (Прерывание связанное с входящим буфером FIFO0) — вызывается по следующим событиям:

— Прием нового сообщения, биты FMP0 в регистре CAN_RF0R не равны «00». В принципе значение этого регистра говорит нем о том, сколько сообщений в буфере FIFO еще не обработано программой;
— Буфер FIFO0 заполнен. Бит FULL0  в регистре CAN_RF0R установлен — сообщает нам о том, что в буфере FIFO0 больше нет свободного места;
— Переполнение буфера FIFO0. Бит FOVR0 в регистре CAN_RF0R установлен — возникает в случае когда буфер FIFO0 заполнен и по шине принято еще одно сообщение. Что с этим сообщением произойдет, мы указываем в настройках инициализации CAN (параметр CAN_RFLM).

• FIFO1 interrupt (Прерывание связанное с входящим буфером FIFO1) — вызывается по следующим событиям:

— Прием нового сообщения, биты FMP1 в регистре CAN_RF1R не равны «00». В принципе значение этого регистра говорит нем о том, сколько сообщений в буфере FIFO еще не обработано программой;
— Буфер FIFO1 заполнен. Бит FULL1  в регистре CAN_RF0R установлен — сообщает нам о том, что в буфере FIFO1 больше нет свободного места;
— Переполнение буфера FIFO1. Бит FOVR1 в регистре CAN_RF0R установлен — возникает в случае когда буфер FIFO1 заполнен и по шине принято еще одно сообщение. Что с этим сообщением произойдет, мы указываем в настройках инициализации CAN (параметр CAN_RFLM).

 • Error and Status change Interrupt (Прерывание по возникновению ошибок и изменению состояния bxCAN) — вызывается по следующим событиям:

— Возникновение ошибки. Информация об ошибке хранится в регистре CAN Error (CAN_ESR);
— «Просыпание» контроллера — выход из режима сна, когда на Rx появился сигнал CAN шины;
— Переход в спящий режим.

Четвертая группа отвечает за прерывания не только ошибок, но, как видно из названия, и за изменения статуса (режима) bxCan. 

Регистры

Полное описание регистров bxCan я приведу в отдельной статье, здесь же мы коснемся лишь некоторых из них, которые непосредственно рассматриваются в рамках данной статьи.

Для того, чтобы мы смогли программно обработать прерывания bxCan, необходимо изучить регистры микроконтроллера, которые непосредственно связаны с этими прерываниями. Разработчики ST Microelectronix постарались для нас и большинство функционала для работы CAN шины возложили на аппаратную часть микроконтроллера, но все же нам придется выполнить некоторые действия самостоятельно.

За обработку ошибок, включение/выключение прерываний CAN шины, а также за информацию о текущем статусе шины и ошибок в bxCan отвечают шесть регистров, которые мы сейчас и изучим:

CAN master status register (CAN_MSR)

Один из основных регистров bxCAN. Он отображает текущее состояние CAN устройства и позволяет программному обеспечению контролировать более детально работу bxCan. 
В большинстве случаев нет необходимости досконально контролировать аппаратную часть, сама bxCan превосходно с этим справляется, но в некоторых случаях будет полезно понимать предоставленные нам возможности и инструменты.

CAN Master Status Register предоставляет нам информацию о том, в каком состоянии находится bxCan и сообщает нам о прерываниях, если они установлены.

Рис. 2. CAN master status register.

Address offset: 0x04
Reset value: 0x0000 0C02

CAN transmit status register (CAN_TSR)

Этот регистр позволяет нам узнать текущее состояние передачи данных в шину. Из него мы можем получить информацию о количестве исходящих сообщений, заполненности почтовых ящиков, узнать о том, отправлено ли нами сообщение или произошла ошибка, а также позволяет нам прервать отправку пакета, если мы почему-то передумали это делать.

Рис. 3. CAN transmit status register.

Address offset: 0x08
Reset value: 0x1C00 0000

Как правило необходимости напрямую обращаться к этому регистру у нас не будет — можно полностью доверится bxCan. Я вижу потребность в его чтении только в очень сложных проектах, где часть функционала ложится не только на аппаратную часть, но и на программную. Также может потребоваться в случаях, когда необходимо использовать парсер CAN-шины — необходимо более детальное изучение ошибок передачи данных, логирование всего и вся.

Для обработки прерываний передачи сообщений необходимо разрешить прерывание при отправке почтового сообщения (CAN_IT_TME) и, соответственно, добавить это обработчик этого прерывания в тело программы (USB_HP_CAN1_TX_IRQHandler()).

CAN receive FIFO 0 register (CAN_RF0R)

Первый из двух регистров, отвечающих за буфер входящих сообщений FIFO 0.

Из этого регистра мы можем узнать количество почтовых сообщений, а также текущее состояние буфера FIFO 0.

Рис. 4. CAN receive FIFO 0 register.

Address offset: 0x0C
Reset value: 0x0000 0000

Обработка прерываний для буфера FIFO 0 происходит в функции USB_LP_CAN1_RX0_IRQHandler(). В ней необходимо обработать получение почтовых сообщений, а также проверить состояние ошибок (заполнение или переполнение буфера FIFO 0). Естественно, необходимо включить эти прерывания при настройке bxCan.

Необходимо помнить, что биты FOVR0 и FULL0 сбрасываются вручную. 

CAN receive FIFO 1 register (CAN_RF1R)

А это второй регистр, предназначенный для чтения состояния буфера входящих сообщений, но уже для FIFO 1.

Из него мы также можем почерпнуть информацию о  том, сколько сообщений у нас хранится и текущий статус самого буфера FIFO 1.

Рис. 5. CAN receive FIFO 1 register.

Address offset: 0x10
Reset value: 0x0000 0000

Для обработки прерываний для буфера FIFO 1 необходимо включить обработку этих прерываний при настройке bxCan и вставить в модуль функцию CAN1_RX1_IRQHandler(). Также как и с буфером FIFO 0, мы можем в обработчике прерываний выполнить обработку получения почтового сообщения в буфер FIFO 1, а также проверить состояние ошибок буфера и сбросить их после обработки.

Также напомню о необходимости сбрасывать биты FOVR1 и FULL1 вручную.

CAN interrupt enable register (CAN_IER)

Мы добрались до регистра, который непосредственно отвечает за включение прерываний bxCAN. Установив необходимые нам биты, мы сможем выполнить обработку прерываний. Напомню, что включение прерываний само по себе недостаточно, необходимо еще и включить сами прерывания и добавить их обработчики в тело программы, иначе наша программа при возникновении прерывания перейдет в прерывание по умолчанию и просто «зависнет». Но об этом поговорим чуть ниже, где я приведу несколько примеров.

Итак, нам необходимо включить прерывания. Сделать это мы можем установив соответствующие биты в регистре CAN interrupt enable register (CAN_IER).

Рис. 6. CAN interrupt enable register.

Address offset: 0x14
Reset value: 0x0000 0000

Если Вы новичок и только начинаете изучать протокол CAN  и его использование на микроконтроллерах семейства STM32, то можно ограничиться одним прерыванием FMPIE0 (FIFO 0 message pending interrupt) и TMEIE (Transmit mailbox empty interrupt), которые отвечает за обработку получения входящего пакета в буфер FIFO 0, а также за обработку окончания отправки пакета в шину соответственно. Для первоначального изучения и тестирования этого вполне хватит, а дальше уже требуется более глубокое понимание физики процессов и специфики работы CAN шины.

CAN error status register (CAN_ESR)

Регистр отвечает за состояние ошибок при работе с bxCan.

Управление ошибками, как описано в протоколе CAN, обрабатывается полностью аппаратными средствами с помощью счетчиков ошибок передачи (TEC — Transmit error counter) и счетчиков ошибок приема сообщений (REC — Receive error counter), которые увеличивают или уменьшают свое значение в соответствии с состоянием ошибки.

Оба счетчика могут быть прочитаны с помощью программного обеспечения, чтобы определить стабильность сети.

Кроме того, аппаратное обеспечение может предоставлять более подробную информацию о текущем состоянии ошибок (LEC — Last error code).

Рис. 7. CAN error status register.

Address offset: 0x18
Reset value: 0x0000 0000

Согласно описанию протокола CAN принято увеличивать счетчик ошибок REC (Receive error counter) на одну единицу при каждой обнаруженной ошибке приема на шине, а счетчик ошибок TEC (Transmit error counter) увеличивать на 8 при каждой ошибке передачи пакетов. Это связано стем, что существует предположение о том, что с наибольшей вероятностью источником ошибок на шине является передающий узел. 

Уменьшение счетчика ошибок происходит автоматически на единицу при каждом успешном приеме или передаче сообщений по шине для счетчиков REC и TEC соответственно.

Восстановление BUS-OFF

Состояние шины Bus-Off устанавливается, когда счетчик ошибок передачи превышает 255, при этом устанавливается бит BOFF регистра CAN_ESR. В этом режиме bxCan фактически перестает принимать и передавать пакеты по шине.

При настройке bxCAN можно установить бит ABOM, который отвечает за то, что если шина перейдет в режим Bus-off, то bxCan автоматически начнет проверять сигнал CAN_RX для восстановления шины. Если бит ABOM не установлен, то разработчику необходимо контролировать этот процесс самостоятельно и в случае возникновения ошибки и перехода в режим Bus-off необходимо заново проинициализировать bxCan.

Обратите внимание, что bxCan слушает порт CAN_RX только в нормальном режиме работы. Если bxCan находится в режиме инициализации, то автоматического восстановления шины не произойдет.

Долгое время не мог понять, что это за 11 рецессивных бит 128 раз подряд и где их необходимо взять и куда подать. Путем гугления и раскурки мануалов понял, что это указывается время, через которое контроллер CAN шины автоматически выйдет из режима Bus-Off и оно равно времени, которое потребуется для передачи 11 рецессивных бит 128 раз подряд.

Другими словами, контроллер автоматически выйдет из режима Bus-Off, когда на CAN шине будет «тишина» в течении времени, равному времени передачи 11 бит * 128 раз. Естественно, если в настройках контроллера мы ему указали, что он может автоматически выходить из этого режима (установлен бит ABOM регистра CAN_MCR).

Практика

Вроде все моменты, которые касаются обработки прерываний bxCan мы рассмотрели. Текста очень много, но как это применить на практике?

Давайте разбираться.

Для начала нам необходимо определится с тем, какие прерывания bxCan мы будем использовать. Конечно можно ограничиться прерыванием на получение сообщения в буфер FIFO, но мы же не ищем легких путей, поэтому проинициализируем сразу все.

За включение/отключение прерываний bxCan отвечает функция CAN_ITConfig, эти действия выполняются в модуле инициализации can шины совместно с настройкой прерываний NVIC:

Листинг №1. Включение прерываний bxCan
	// CAN Transmit mailbox empty Interrupt enable
	// Обрабатывается в прерывании USB_HP_CAN1_TX_IRQHandler
	CAN_ITConfig(CAN1, CAN_IT_TME, ENABLE);         // Прерывание при освобождении исходящего почтового ящика
	// CAN Receive Interrupt enable
	// Обрабатывается в прерывании USB_LP_CAN1_RX0_IRQHandler
	CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);        // Прерывание получения пакета в буфер FIFO 0
	CAN_ITConfig(CAN1, CAN_IT_FF0, ENABLE);         // Прерывание при заполнении буфера FIFO 0
	CAN_ITConfig(CAN1, CAN_IT_FOV0, ENABLE);        // Прерывание при переполнении буфера FIFO 0
 
	// Обрабатывается в прерывании CAN1_RX1_IRQHandler
	CAN_ITConfig(CAN1, CAN_IT_FMP1, ENABLE);        // Прерывание получения пакета в буфер FIFO 1
	CAN_ITConfig(CAN1, CAN_IT_FF1, ENABLE);         // Прерывание при заполнении буфера FIFO 1
	CAN_ITConfig(CAN1, CAN_IT_FOV1, ENABLE);        // Прерывание при переполнении буфера FIFO 1
 
	// CAN Operating Mode Interrupt enable
	// Обрабатывается в прерывании CAN1_SCE_IRQHandler
	CAN_ITConfig(CAN1, CAN_IT_WKU, ENABLE);         // Прерывание при "пробуждении" - выход из "спящего" режима
	CAN_ITConfig(CAN1, CAN_IT_SLK, ENABLE);         // Прерывание при переходе в "спящий" режим
 
	// CAN Error Interrupts
	// Обрабатывается в прерывании CAN1_SCE_IRQHandler
	CAN_ITConfig(CAN1, CAN_IT_EWG, ENABLE);         // Error warning Interrupt (error counter >= 96)
	CAN_ITConfig(CAN1, CAN_IT_EPV, ENABLE);         // Error passive Interrupt (error counter > 127)
	CAN_ITConfig(CAN1, CAN_IT_BOF, ENABLE);         // Bus-off Interrupt (error counter > 255)
	CAN_ITConfig(CAN1, CAN_IT_LEC, ENABLE);         // Last error code - при возникновении ошибок приема-передачи
	CAN_ITConfig(CAN1, CAN_IT_ERR, ENABLE);         // Прерывание при возникновении ошибок bxCan


	// NVIC Configuration
	NVIC_InitTypeDef NVIC_InitStructure;

	// Enable CAN1 TX0 interrupt IRQ channel
	NVIC_InitStructure.NVIC_IRQChannel = USB_HP_CAN1_TX_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);

	// Enable CAN1 RX0 interrupt IRQ channel
	NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);

	// Enable CAN1 RX1 interrupt IRQ channel
	NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);

	// Enable CAN1 SCE (Status Change Error) interrupt IRQ channel
	NVIC_InitStructure.NVIC_IRQChannel = CAN1_SCE_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);

После того, как с помощью функции CAN_ITConfig() мы проинициализировали необходимые нам прерывания, необходимо включить обработчики этих прерываний. Делается это через NVIC. Если мы забудем хотя бы одно из них включить, то микроконтроллер при возникновении прерывания, которое мы забыли обработать, выкинет нас в стандартный обработчик прерываний и просто зависнет. Поможет только перезагрузка процессора, так как он будет сидеть в «вечном» цикле и ни на что больше реагировать не будет.

А теперь, чтобы этого не произошло, нам необходимо вставить в наш программный код функции обработки прерываний. Всего их четыре: прерывание при освобождении исходящего почтового ящика, два прерывания для буферов FIFO 1 и 2, а также прерывание по обработке ошибок и входа/выхода в «режим сна».

Обработка прерываний при освобождении исходящего почтового ящика

За обработку прерывания при освобождении исходящего почтового ящика отвечает функция USB_HP_CAN1_TX_IRQHandler(). Нам необходимо проверить флаг прерывания и, если он установлен, сбросить его и выполнить код обработки прерывания:

Листинг №2. Обработка прерываний bxCan для исходящего почтового ящика
void USB_HP_CAN1_TX_IRQHandler(void)
{
	// CAN Transmit mailbox empty Interrupt enable
	// Обработаем прерывания при освобождении исходящего почтового ящика
	if (CAN_GetITStatus(CAN1, CAN_IT_TME)==SET) {       // Прерывание при освобождении исходящего почтового ящика
		CAN_ClearITPendingBit(CAN1, CAN_IT_TME);
   
		// Вставляем свой код по обработке прерывания
	}
}

Функция CAN_GetITStatus() возвращает текущее состояние флага прерывания, значение может быть равным SET или RESET («Установлен» или «сброшен» соответственно). Значение SET говорит нам о том, что бит установлен и нам необходимо обработать это прерывание и не забыть сбросить его флаг.

Следует помнить о том, что необходимо всегда производить сброс флага прерывания, иначе оно будет вызываться постоянно. Исключение составляют только флаги прерываний ошибок, они почти все сбрасываются аппаратно, подробнее можно посмотреть в описании функции CAN_ClearITPendingBit().

Проверять освобождение исходящего почтового ящика имеет смысл, если Вы пересылаете большой объем данных по Can-шине: при обработке отправки сообщения выставляется флаг отправки сообщения, а в прерывании проверяется была выполнена отправка данных или нет. Если отправка была завершена без ошибок, то устанавливаем в флаг значение без ошибок и отправляем следующий пакет данных, иначе устанавливаем в флаг код ошибки и обрабатываем ее в модуле программы.

Несмотря на то, что исходящих почтовых ящиков у нас три, проверять отправку сообщений я все же рекомендую, иначе вполне вероятны ситуации, когда в результате проигрыша арбитража или возникновении ошибок на линии bxCan не сможет отправить сообщения, а мы в этот момент, не проверив статус отправки, будем давать ему новые на отправку. Возникнет сбой, который нам не нужен.

Проверить статус отправки сообщения можно не только с помощью прерываний, но и в момент отправки сообщения (это наверное самый оптимальный вариант):

Листинг №3. Отправка сообщения с проверкой статуса отправки
	uint32_t i = 0;
	uint8_t TransmitMailbox = 0;
	
	...
	
	TransmitMailbox = CAN_Transmit(CAN1, &TxMessage);
	i = 0;
	while ((CAN_TransmitStatus(CAN1, TransmitMailbox) != CANTXOK) && (i != 0xFF)) 	{
		i++;
	}

При передаче сообщения через функцию CAN_Transmit, она нам возвращает номер исходящего почтового ящика, в который помещено сообщение. Затем мы в цикле проверяем, отправил ли bxCan наше сообщение или нет. Если отправка прошла успешно, то статус отправки сообщения из почтового ящика будет равен CANTXOK.

По окончанию цикла while() проверяем значение переменной «i». Если оно у нас равно 0xFF, значит отправка не удалась и тут мы уже думаем что сделать: то ли сбросить отправку сообщения, то ли обработать ошибку.

Вообщем все на усмотрение разработчика.

Обработка прерываний входящего буфера сообщений FIFO 0

За прерывания для входящего буфера сообщений FIFO 0 отвечают флаги CAN_IT_FMP0, CAN_IT_FF0 и CAN_IT_FOV0.

Таб. 1. Прерывания  буфера FIFO 0

Заполнение, а тем более переполнение буфера входящих сообщений говорит о том, что Ваша программа не успевает их обрабатывать. Здесь уже необходимо искать причину в организации работы CAN шины и поиграться с установкой фильтров сообщений.

Фильтры помогут на аппаратном уровне отсеивать пакеты с ненужными нам данными, чтобы не тратить время и ресурсы процессора на обработку ненужной информации. Подробнее работу с фильтрами я описал в статье STM32. Почтовые ящики. Фильтры пакетов CAN.

Действия по обработке данных прерываний возлагаются на разработчика и описываются в функции USB_LP_CAN1_RX0_IRQHandler().

Листинг №4. Обработка прерываний bxCan для буфера FIFO 0
void USB_LP_CAN1_RX0_IRQHandler(void)
{
	CanRxMsg RxMessage;
	
	// CAN Receive Interrupt enable FIFO 0
	// Обработаем прерывания приемного буфера FIFO 0
	if (CAN_GetITStatus(CAN1, CAN_IT_FMP0) == SET) {                   // Прерывание получения пакета в буфер FIFO 0
		// Флаг сбрасывается автоматически после прочтения последнего сообщения
   
		// Обнулим данные пакета
		RxMessage.DLC =     0x00;
		RxMessage.ExtId =   0x00;
		RxMessage.FMI =     0x00;
		RxMessage.IDE =     0x00;
		RxMessage.RTR =     0x00;
		RxMessage.StdId =   0x00;
		RxMessage.Data [0] = 0x00;
		RxMessage.Data [1] = 0x00;
		RxMessage.Data [2] = 0x00;
		RxMessage.Data [3] = 0x00;
		RxMessage.Data [4] = 0x00;
		RxMessage.Data [5] = 0x00;
		RxMessage.Data [6] = 0x00;
		RxMessage.Data [7] = 0x00;
		
		CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);                   // Получим сообщение
   
		// Вставляем любой свой код обработки входящего пакета
   
		}
   
	if (CAN_GetITStatus(CAN1, CAN_IT_FF0)==SET) {                       // Прерывание при заполнении буфера FIFO 0
		CAN_ClearITPendingBit(CAN1, CAN_IT_FF0);
		
		// Вставляем свой код по обработке прерывания
 		
		// Не забываем после обработки сбросить флаг ошибки
		CAN_ClearFlag(CAN1, CAN_FLAG_FF0);
	}
	
	if (CAN_GetITStatus(CAN1, CAN_IT_FOV0)==SET) {                      // Прерывание при переполнении буфера FIFO 0
		CAN_ClearITPendingBit(CAN1, CAN_IT_FOV0);
		
		// Вставляем свой код по обработке прерывания
   
		// Не забываем после обработки сбросить флаг ошибки
		CAN_ClearFlag(CAN1, CAN_FLAG_FOV0);
	}
}

Следует обратить внимание на то, что функция USB_LP_CAN1_RX0_IRQHandler() предназначена как для обработки прерываний bxCan так и для обработки прерываний USB. Если Вы будете использовать USB в своем проекте, то нужно внимательно подойти к этому моменту, чтобы правильно обрабатывать сообщения для каждого устройства.

Обратите внимание, что в обработчике прерываний мы сбрасываем не только флаг прерывания, но также сбрасываем флаг ошибки bxCan. Это немного (точнее очень много) разные вещи: флаг прерывания отвечает за то, что мы попадем в обработчик прерывания при его установке и если его не сбросить, то мы можем сидеть вечно в этом обработчике. А флаг ошибки сигнализирует нам о том, что есть ошибка и его нужно снять после того, как мы обработали эту ошибку. Соответственно, если по какой-либо причине мы ее не обработали — этот флаг снимать не следует.

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

Обработка прерываний входящего буфера сообщений FIFO 1

За прерывания для входящего буфера сообщений FIFO 1 отвечают флаги CAN_IT_FMP1, CAN_IT_FF1 и CAN_IT_FOV1. Описание и действие аналогично с обработкой прерывания для буфера FIFO 0.

Таб. 2. Прерывания  буфера FIFO 1

В отличии от буфера FIFO 0, обработка этих прерываний происходит в функции CAN1_RX1_IRQHandler().

Листинг №5. Обработка прерываний bxCan для буфера FIFO 1
void CAN1_RX1_IRQHandler(void)
{
	CanRxMsg RxMessage;
   
	// CAN Receive Interrupt enable FIFO 1
	// Обработаем прерывания приеного буфера FIFO 1
	if (CAN_GetITStatus(CAN1, CAN_IT_FMP1) == SET) {              // Прерывание получения пакета в буфер FIFO 1
		// Флаг сбрасывается автоматически после прочтения последнего сообщения
   
		// Обнулим данные пакета
		RxMessage.DLC =     0x00;
		RxMessage.ExtId =   0x00;
		RxMessage.FMI =     0x00;
		RxMessage.IDE =     0x00;
		RxMessage.RTR =     0x00;
		RxMessage.StdId =   0x00;
		RxMessage.Data [0] = 0x00;
		RxMessage.Data [1] = 0x00;
		RxMessage.Data [2] = 0x00;
		RxMessage.Data [3] = 0x00;
		RxMessage.Data [4] = 0x00;
		RxMessage.Data [5] = 0x00;
		RxMessage.Data [6] = 0x00;
		RxMessage.Data [7] = 0x00;
   
		CAN_Receive(CAN1, CAN_FIFO1, &RxMessage);               // Получим сообщение
   
		// Вставляем любой свой код обработки входящего пакета
   
	}
   
	if (CAN_GetITStatus(CAN1, CAN_IT_FF1)==SET) {                   // Прерывание при заполнении буфера FIFO 1
		CAN_ClearITPendingBit(CAN1, CAN_IT_FF1);
   
		// Вставляем свой код по обработке прерывания
   
		// Не забываем после обработки сбросить флаг ошибки
		CAN_ClearFlag(CAN1, CAN_FLAG_FF1);
	}

	if (CAN_GetITStatus(CAN1, CAN_IT_FOV1)==SET) {                  // Прерывание при переполнении буфера FIFO 1
		CAN_ClearITPendingBit(CAN1, CAN_IT_FOV1);

		/ Вставляем свой код по обработке прерывания
   
		// Не забываем после обработки сбросить флаг ошибки
		CAN_ClearFlag(CAN1, CAN_FLAG_FF1);
	}
}

Обработчик для буфера FIFO 1 ничем не отличается от обработчика для буфера FIFO 0, разница есть только в наименовании функции обработчика и флагов, которые мы проверяем. Наполнение буфера FIFO 1 (как и FIFO 0) зависит исключительно от настроек фильтрации пакетов и в них же указывается какие сообщения в какой буфер будут попадать.

Подробно я о фильтрах рассказывал в статье STM32. Почтовые ящики. Фильтры пакетов CAN.

В своем проекте управления умным домом я с помощью фильтрации разделяю управляющие пакеты и пакеты с данными по разным буферам: сообщения данных попадают исключительно в буфер FIFO 0, а системные и приоритетные сообщения я помещаю в буфер FIFO 1.

Если у Вас нет задачи такой фильтрации сообщений, то можно вполне обойтись одним буфером FIFO 0  и в принципе не использовать буфер FIFO 1 (или наоборот, роли никакой не играет). Для большинства задач это будет вполне достаточно и сэкономит Вам несколько сотен байт прошивки.

Обработка прерываний по ошибкам и «спящему» режиму

Обработчик прерываний ошибок bxCan позволяет нам определить насколько стабильно работает наше устройство с протоколом CAN и вовремя принять меры для достижения максимально стабильного режима работы.

За обработку ошибок отвечают следующие флаги:

Таб. 3. Прерывания ошибок и режима шины

Прерывание по флагам CAN_IT_WKU и CAN_IT_SLK срабатывают при входе или выходе в/из спящего режима. При этом флаг CAN_IT_ERR не устанавливается. А если же срабатывает прерывание по флагам CAN_IT_EWG, CAN_IT_EPV, CAN_IT_BOF или CAN_IT_LEC, то одновременно с ними устанавливается и флаг CAN_IT_ERR.

Флаги CAN_IT_EWG, CAN_IT_EPV и CAN_IT_BOF предназначены для контроля количества ошибок приема передачи по шине. Механизм bxxCan не только увеличивает счетчик ошибок, например когда на линии возникает помеха и счетчик ошибок увеличивается, но и уменьшает его, когда работа шины нормализуется. Флаги CAN_IT_EWG и CAN_IT_EPV являются предупреждающими о том, что идет рост ошибок и необходимо выявить причину их возникновения, а вот флаг CAN_IT_BOF нам сообщает, что счетчик ошибок достиг своего максимума и шина перешла в режим Bus-off. Выход из этого режима может произойти автоматически (при получении 128 раз 11 рецессивных бит подряд по шине) или принудительно — заново проинициализировав bxCan.

Напомню, что за автоматический выход из режима Bus-Off отвечает бит ABOM в регистре CAN_MCR. Рекомендую его устанавливать в Ваших проектах, тогда bxCan этот функционал возьмет на себя.

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

С тем что обрабатывать — мы определились, теперь необходимо вставить в программный модуль и саму функцию обработки прерываний ошибок CAN1_SCE_IRQHandler().

В ней мы сформируем шаблон обработки исключений, возникающих при работе bxCan:

Листинг №6. Обработка прерываний засыпания/пробуждения и ошибок bxCan
void CAN1_SCE_IRQHandler(void)
{
	uint8_t errorcode = 0;

	if (CAN_GetITStatus(CAN1, CAN_IT_ERR)==SET)    {                   // Прерывание при возникновении ошибки
		CAN_ClearITPendingBit(CAN1, CAN_IT_ERR);

		// CAN Error Interrupts
		// Обработка прерываний по ошибке
		if (CAN_GetITStatus(CAN1, CAN_IT_EWG)==SET) {              // Error warning Interrupt (счетчик ошибок >= 96)
			CAN_ClearITPendingBit(CAN1, CAN_IT_EWG);

			// Вставляем свой код по обработке прерывания
		}
   
		if (CAN_GetITStatus(CAN1, CAN_IT_EPV)==SET) {              // Error passive Interrupt  (счетчик ошибок > 127)
			CAN_ClearITPendingBit(CAN1, CAN_IT_EPV);

			// Вставляем свой код по обработке прерывания
		}
   
		if (CAN_GetITStatus(CAN1, CAN_IT_BOF)==SET) {              // Bus-off. Прерывание при переполнении счетчика ошибок (>255)
			CAN_ClearITPendingBit(CAN1, CAN_IT_BOF);           // bxCan уходит в режим Bus-OFF

			// Вставляем свой код по обработке прерывания
		}
   
		if (CAN_GetITStatus(CAN1, CAN_IT_LEC)==SET) {              // Прерывание при ошибке приема передачи сообщения
			CAN_ClearITPendingBit(CAN1, CAN_IT_LEC);
			errorcode = CAN_GetLastErrorCode(CAN1);            // Получим код ошибки
   
			// Вставляем свой код по обработке прерывания

			// Не забываем после обработки сбросить флаг ошибки
			CAN_ClearFlag(CAN1, CAN_FLAG_LEC);
		}

	} else {

		// CAN Operating Mode Interrupt
		// Обработка прерываний по режимам сна/пробуждения
		if (CAN_GetITStatus(CAN1, CAN_IT_WKU)==SET) {             // Прерывание при "пробуждении" - выход из "спящего" режима
			CAN_ClearITPendingBit(CAN1, CAN_IT_WKU);

			// Вставляем свой код по обработке прерывания
   
			// Не забываем после обработки сбросить флаг ошибки
			CAN_ClearFlag(CAN1, CAN_FLAG_WKU);
		}

		if (CAN_GetITStatus(CAN1, CAN_IT_SLK)==SET) {             // Прерывание при переходе в "спящий" режим
			CAN_ClearITPendingBit(CAN1, CAN_IT_SLK);

			// Вставляем свой код по обработке прерывания
   
			// Не забываем после обработки сбросить флаг ошибки
			CAN_ClearFlag(CAN1, CAN_FLAG_SLAK);
		}
	}
}

Также как мы сбрасываем флаги прерываний, нам необходимо сбрасывать и флаги ошибок после их обработки. Но если обратить внимание на описание регистров, то мы видим, что часть флагов ошибок сбрасываются автоматически аппаратными средствами bxCan, а часть мы должны очищать вручную. Вот и сейчас при обработке ошибок мы можем сбросить только флаги CAN_IT_LEC, CAN_IT_WKU и CAN_IT_SLK, а остальные флаги ошибок в данном обработчике прерываний сбрасываются автоматически.

Не стоит забывать и о том, что перед сбросом флага ошибки мы должны ее (ошибку) обработать и уже потом менять флаг.

Еще стоит обратить внимание на обработку прерывания CAN_IT_LEC (Last Error Code), которая появляется при возникновении ошибок ввода-вывода.

В обработчике  с помощью функции CAN_GetLastErrorCode() мы заполняем переменную errorcode данными о последней ошибке. Она может принимать следующие значения:

 Таб. 4. Виды ошибок, возвращаемые при вызове функции CAN_GetLastErrorCode()

Таким образом, обрабатывая флаг CAN_IT_LEC и изучая ошибки, которые происходят при работе с CAN, мы можем заблаговременно выявить причину и предпринять некоторые действия для того, что бы предотвратить рост ошибок и сваливание CAN контроллера в режим Bus-Off.

Заключение

В этой статье я постарался подробно описать механизмы обработки прерываний bxCan, а также механизмы связанные с обработкой ошибок и методы по их сокращению. Напомню, что все тестирование кода производилось на базе микроконтроллера STM32F103C6.

Вполне вероятно, что я что-то упустил, где то наоборот ошибся и был не точен. Поэтому если есть какие-либо замечания и/или предложения к статье — добро пожаловать в комменты и я исправлюсь.

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

З.Ы. Простите за много букафф )))

Здравствуйте.

У большинства читателей шина CAN ассоциируется с автомобилем. Однако если вы не автолюбитель не спешите закрывать статью так как использовать CAN можно где угодно, например в постройке «умного дома», или ещё где-то, где необходима надёжная передача данных.

Преимущества CAN-шины заключаются в том, что требуется всего два провода (витая пара), данные можно передавать на большие расстояния (вплоть до нескольких километров), устойчивость к сильным помехам, и способность автоматически восстанавливать работоспособность после сбоев.

Вся эта надёжность достигается за счёт сложного механизма обработки данных, с помощью таймингов, сегментов, и прочей хитроумной фигни, которую мы рассмотрим по ходу статьи.

Единственный неудобный момент, это необходимость в специальном CAN-трансивере (маленькая восьминогая микруха). Чтобы ничего не паять, можно купить на Али вот такие штуки…

Этот трансивер (SN65HVD230, маркируется как VP230) питается от 3.3V, что несомненно является удобством при работе с stm32. Так же можно использовать другие популярные трансиверы — MCP2551 и TJA1050 (он же A1050). У TJA1050 есть небольшой недостаток — в даташите написано что он не поддерживает скорости ниже 60Кбит/с, правда у меня работал даже на меньших скоростях, но не всегда стабильно. Впрочем это не страшно так как вряд ли вы будете использовать столь низкую скорость в своих проектах.

Контакты CTX и CRX подключаются к stm32, а CANH и CANL к витой паре. «Земли» соединять не нужно, это дифференциальный сигнал. К каждой stm’ки подключается свой трансивер.

Топология сети такова…

На шине могут находиться два и более устройств (можно любое количество, однако практически оно ограничивается нагрузочной способностью передатчиков и колеблется от 100 до 200). На двух крайних устройствах должны быть установлены терминирующие резисторы (120 Ом). На платках, про которые я писал выше они уже есть. Если на шине присутствуют промежуточные устройства, то на них резисторы не устанавливаются (на платках выше, их нужно выпаять).

Не рекомендуется делать длинные ответвления для промежуточных устройств, по хорошему ответвлений вообще не должно быть, должно быть так…

Сеть похожа на RS485, но в CAN-шине не нужно программно выбирать направление передачи, нет мастера и слейвов, и нет идентификаторов устройств как у I2C. Каждый шлёт свои данные когда хочет, получают их все присутствующие на шине устройства, а разруливается всё это аппаратно самим CAN-интерфейсом. Подробнее об это ниже.

Пока вы не приобрели трансиверы, можно будет поэкспериментировать без них, для этого есть специальный режим когда одна stm’ка, может сама себе посылать пакеты на одном интерфейсе (и нет, для этого не нужно замыкать между собой ножки как это иногда делается с UART’ом, так работать не будет).

Максимальная скорость передачи 1Мбит/с. Сейчас делаются устройства с большей скоростью (CAN FD), но это нас не интересует.

Длина линии зависит от скорости передачи:

1000 Кбит/с — 40 метров.
500 Кбит/с — 100 метров.
250 Кбит/с — 200 метров.
125 Кбит/с — 500 метров.
10 Кбит/с — 6 километров.

Это наиболее распространённые скорости в промышленности, но встречаются и другие — 800 Кбит/с, 400 Кбит/с, 83.333 Кбит/с, 50 Кбит/с, 20 Кбит/с. Да и вообще можно настроить любую скорость в своих проектах, правда смысла в этом особого нет.

Теперь перейдём к более подробному рассмотрению CAN-шины.

Далее я буду называть устройства подключённые к шине узлами.

Данные в CAN-шине передаются небольшими пакетами, которые называются кадрами (frame). Существуют четыре типа кадров:

Data Frame — основной кадр, в котором передаются различные полезные данные.

Remote Frame — это кадр не содержит полезных данных, и служит для того, чтобы «попросить» какой-либо узел послать кадр. То есть, какой-то узел посылает этот кадр в сеть, а другой узел (который понимает что обращаются к нему) отправляет кадр с полезными данными. Такой способ подходит для опроса каких-то датчиков и немного снижает нагрузку на сеть. О том, как узел понимает что обращаются к нему написано ниже. А вот тут написано что не рекомендуется использовать Remote Frame.

Error Frame — кадр ошибки. Когда один из узлов обнаруживает ошибку формата кадра, он посылает в сеть Error Frame (имеет наивысший приоритет). Другие узлы получая Error Frame понимают что в сети произошла ошибка и последнее сообщение надо считать некорректным.

Overload Frame — этот кадр посылается узлом, который сильно перегружен и не успел переварить входящие сообщения. Послав в сеть кадр Overload Frame он как-бы просит другие узлы подождать немножко и повторно прислать сообщения. Это тоже происходит аппаратно. Сейчас этот кадр практически не используется так как CAN-контроллеры достаточно мощные чтоб успевать всё обработать.

Кадры Error Frame и Overload Frame передаются узлами аппаратно, без нашего участия.

Начнём с детального разбора Data Frame и потихоньку коснёмся всего.

Если мы подключимся к шине CAN-снифером работающим с программой Can Hacker и пульнём в шину кадр, то увидим в программе следующее…

Так выглядит кадр в CAN-шине глазами обывателя. Здесь есть идентификатор кадра (ID), количество полезных байт (DLC), и сами полезные байты (Data), восемь штук. Для анализа CAN-шины этого достаточно.

Все данные в CAN записываются в HEX формате. То есть в нашем случае идентификатор — это 0x0280.

К недостаткам CAN-шины можно отнести ограниченное количество передаваемых полезных байт в одном кадре, их может быть не больше восьми. Меньше можно.

А теперь посмотрим на кадр глазами программиста…

Здесь мы видим:

SOF (Start of Frame) — стартовый бит сообщающий о начале кадра. Позже мы к нему вернёмся так как он выполняет важную роль в работе всей сети.

Identifier — идентификатор кадра. Подчеркну,

это не идентификатор какого-либо узла сети, это идентификатор именно кадра. Узлы CAN-шины не имеют никаких идентификаторов или любой другой адресации. Когда какой-то узел посылает кадр, его получают все имеющиеся в сети узлы, и далее каждый узел смотрит на идентификатор и решает нужно ли ему обрабатывать этот кадр или просто отбросить

. То есть, при проектировании сети вы прописываете в каждом узле какие идентификаторы ему нужно принять и обработать, а какие игнорировать. При этом вам не надо проверять идентификаторы «вручную» в своей программе. Для этого у stm32 есть аппаратная фильтрация кадров, которая с помощью настраиваемых фильтров сама решает что сделать с кадром имеющим тот или иной идентификатор. То есть, например, вы настроили фильтр так, чтоб принимался только кадр с идентификатором 280, тогда кадры с другими идентификаторами будут отбрасываться аппаратно, не создавая нагрузки на ЦПУ. Фильтры можно настраивать на приём нескольких идентификаторов или группы, или нескольких групп. В общем достаточно гибкая система. Благодаря этой аппаратной фильтрации вам не нужно беспокоится о том, переварят ли вашы узлы весь трафик, даже если он очень плотный.

Идентификаторы бывают двух видов. Изначально, когда проектировалась шина CAN было решено сделать идентификатор 11-ти битным, то есть количество идентификаторов было от 0х00 до 0x07FF (0 — 2047), то есть всего 2048. Спустя некоторое время пришли к выводу что это слишком мало и придумали 29-ти битный идентификатор — от 0х00 до 1FFFFFFF (0 — 536870911). Однако для совместимости с прежней системой решили не увеличивать поле для идентификатора у старого кадра, а сделали два вида кадров. Первый остался с 11-ти битным идентификатором и его назвали

стандартным

. Второй получил 29-ти битный идентификатор и его назвали

расширенным

. Таким образом у CAN-шины появилось два вида Data Frame, стандартный и расширенный.

Поле

Identifier

на картинке обведено фигурной скобкой подписанной как

Arbitration

. Это говорит о том, идентификатор выполняет ещё и арбитраж на шине — задаёт приоритет кадра.

Чем меньше числовое значение идентификатора кадра, тем выше у него приоритет над другими кадрами

(см. ниже). Помимо этого, у расширенного кадра приоритет выше чем у стандартного.

RTR — один бит. Если этот бит равен нулю, значит передаётся

Data Frame

, если равен единице, значит передаётся

Remote Frame

.

IDE — один бит. Если этот бит равен нулю, значит передаётся стандартный кадр, если равен единице, значит передаётся расширенный кадр.

R — зарезервированный на будущее бит.

DLC — четыре бита определяющие количество полезных байт (DATA) в кадре.

DATA — полезные данные.

CRC — контрольная сумма кадра. Аппаратно вычисляется на основе передаваемых битов (от SOF до поля DATA включительно) и полинома генератора G(x), определенного в ISO 11898-1.

DEL — разделительный бит.

ACK — это бит подтверждения корректной отправки кадра. Перед отправкой кадра передатчик записывает в этот бит единицу… А вот чтоб объяснить что происходит дальше придётся кратко описать работу протокола CAN

(чуть ниже)

.

EOF (End of Frame) — конец кадра. Семь бит высокого уровня.

ITM — три бита высокого уровня для отделения переданного кадра от следующего.

В спецификации CAN высокий уровень

(логическая единица)

называется рецессивным, а низкий

(логический ноль)

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

Когда никто ничего не передаёт, на линии устанавливается напряжение ~2.5 вольта, это значит что шина свободна.

Когда узел хочет передать кадр, он «щупает» шину и если она свободна начинает передачу. Если же шина окажется занята, тогда узел не станет ничего передавать, а будет постоянно «прощупывать» шину в ожидании когда она освободится. Как только она освободится узел тут же начнёт передачу. Такой механизм позволяет узлам не мешать друг другу.

Однако не всё так просто. Поскольку в CAN-шине происходит весьма интенсивный обмен данными, часто происходит так, что два или несколько узлов видят что шина свободна и одномоментно начинают передачу. Вот тут в дело вступает побитовый арбитраж шины основывающийся на идентификаторах кадров.

Арбитраж работает очень просто. Итак, у нас два (или более) узла начали одновременно передавать кадры в шину…

Первый узел (Device A) передаёт кадр с идентификатором 0х0647, а второй (Device В) с идентификатором 0х06C7.

Поскольку узлы ничего не знают друг о друге, то при передаче каждого бита они постоянно мониторят («прощупывают») линию. Если узел передающий в данный момент единицу обнаружит что кто-то в этот же момент передаёт ноль, тогда он тут же прекратит передачу (так как ноль имеет более высокий приоритет чем единица) и будет ждать освобождения шины. Это проиллюстрировано на картинке выше.

В самом начале линия была свободна находясь в высоком (рецессивном) состоянии, далее оба узла передали стартовый бит (низкое состояние, оно же доминантное), далее оба начали передавать идентификаторы. Сначала две единицы, далее один ноль, и наконец первый узел передал ещё один ноль, а второй передал единицу и проиграл арбитраж, так как доминантный уровень (ноль) имеет приоритет над рецессивным (единица). Теперь второй узел будет ждать когда шина освободится и попытается повторить отправку.

Таким образом идентификаторы определяют какой кадр полетит первым, а какой подождёт. Однако возникает вопрос, что произойдёт если два узла одновременно пошлют в сеть кадры с одинаковыми идентификаторами? А ответ очень прост — спецификация CAN предполагает что в сети не должно быть узлов посылающих одинаковые идентификаторы. Тем не менее вы можете сделать так, что у вас несколько узлов будут посылать одинаковые идентификаторы, однако необходимо организовать работу так, чтоб они не ломились в сеть одновременно.

Исходя из прочитанного про арбитраж, становиться ясно что функционирование всей шины, её стабильность и правильная работа, завязана на том, что все узлы должны быть чётко синхронизированы между собой. Синхронизация узлов происходит каждый раз когда кто-то начинает передачу, то есть когда на линии появляется SOF — стартовый бит. Как только он появился все узлы тут же начинают отсчёт времени. Ещё существует ресинхронизация во время передачи кадра, но об этом позже.

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

Если никто из узлов не «ответил», тогда в зависимости от настроек, кадр будет отправлен повторно, либо не будет (см. ниже «Automatic Retransmision»).

Далее займёмся непосредственно настройкой и продолжим изучение.

Традиционно я буду делать описание для BluePill, однако оно так же справедливо и для других камней. Настройка двух CANов на одном МК тоже будет описана.

Если у вас камень с двумя CANами, тогда настраивайте первый, второй не трогайте.

Итак, первым делом нужно посмотреть в мануале на какой шине у вас висит интерфейс CAN. У F103, F105, F205, F303, F407 и F446 это шина

APB1

…

Желательно чтоб частота этой шины была либо 16 МГц, либо 32 МГц. Это нужно для оптимальной настройки.

Теперь активируем CAN и видим различные настройки (у меня уже настроено для скорости 500Кб)…

Первый раздел (Bit Timings Parameters) самый сложный, он отвечает за настройку таймингов и скорости передачи.

Выше я писал что CAN-интерфейс тщательно мониторит линию. Так вот, мониторится не просто логические уровни, а каждый бит (не байт, а именно бит) «раскладывается» на сегменты которые должны длиться определённое количество квантов времени.

В данном примере один квант времени равен 125.0 наносекунд (Time Quantum).

Вот так выглядит один бит разложенный на сегменты SYNC_SEG, PROP_SEG, PHASE_SEG1 и PHASE_SEG2…

Теперь разберёмся что же мы будем настраивать и как оно работает…

System Clock

это частота шины APB1. Предделителем (Prescaler) мы делим её на какое-то число и получаем время одного кванта (tQ). То есть один квант будет равен одному «тику»

CAN System Clock

.

Согласно спецификации CAN, сегмент SYNC_SEG всегда длится ровно один квант. Остальные три сегмента могут длится от 1 до 8 квантов. Их количество нужно настраивать. Время одного кванта и количество этих квантов в одном бите определяет скорость шины (см. ниже).

О том, какую функцию выполняют сегменты, вы можете почитать в мануале по ссылке ниже. Здесь я это расписывать не буду так как во-первых это муторно, а во-вторых практического смысла в этих пояснениях нет ибо всё это работает аппаратно. Если в двух словах, то они нужны для коррекции и постоянной ресинхронизации шины в процессе передачи кадра, так как из-за удалённости узлов друг от друга и не идеальности кварцевых резонаторов установленных на них, происходит расхождение времени, а шина должна работать чётко синхронно.

Sample Point

— это точка в которой происходит «захват» бита.

Количество квантов в сегментах PROP_SEG, PHASE_SEG1 и PHASE_SEG2 настраивается так, чтобы Sample Point находилась в районе 87.5% длительности бита (см. ниже).

Все эти сегменты работают аппаратно.

Это очень поверхностное описание, сделанное чтоб вы понимали за что отвечают настройки в Кубе. Все подробности и нюансы можно почитать в этом мануале.

Итак, вернёмся в Куб и теперь уже более осмысленно посмотрим что у меня там настроено…

Указываем

Prescaler (for Time Quantum)

4 и получаем время одного кванта

Time Quantum

125 нс. Частота APB1 у нас 32МГц, делим на 4, получаем 8МГц, 1 / 8000000 = 0.000000125.

Time Quanta in Bit Segment 1

— это количество квантов из которых состоят два сегмента PROP_SEG и PHASE_SEG1 (они объединены).

Time Quanta in Bit Segment 2

— это количество квантов из которых состоит последний сегмент (PHASE_SEG2).

В результате получается что один бит у нас состоит из 16 квантов — SYNC_SEG (один квант) + Bit Segment 1 + Bit Segment 2, общей длительностью 2000 нс (Time for one Bit). Соответственно скорость передачи данных (Baud Rate) получилась 500 Кбит/с.

ReSynchronization Jamp Width

— это значение от 1 до 4 квантов, на которое может аппаратно увеличиваться или уменьшаться длительность сегментов PHASE_SEG1 и PHASE_SEG2 для более точной коррекции. Цель коррекции — поместить точку «захвата» бита в более удачный момент и ресинхронизировать узлы на шине. Короче говоря, на сколько я понимаю, если линия очень длинная или вокруг неё много помех, из-за чего может проявляться неустойчивая работа, тогда это значение можно увеличить для улучшения стабильности. Однако увеличивая это значение вы снижаете скорость передачи.

Ну и на конец разберёмся откуда взялись цифры 13 (Bit Segment 1) и 2 (Bit Segment 2).

Откройте онлайн калькулятор…

В выпадающем списке выберите

ST Microelectronics bxCAN

и в

Clock Rate

укажите частоту APB1 шины, в нашем случае это 32.

Как видите здесь написано что 87.5% это предпочтительное значение для захвата бита (выше я про это говорил). Больше нам ничего не нужно. Теперь нажмите кнопку

Request Table

и получите такую картинку…

В первой колонке показаны скорости которые вы можете настроить. Смотрим значения для 500 Кбит/с (жёлтым выделены оптимальные значения). Всё как в нашем примере — предделитель 4, общее количество квантов 16, 13 квантов для Bit Segment 1, и 2 кванта для Bit Segment 2. Sample Point получился 87.5%.

Если например захотите настроить скорость 250 Кбит/с, тогда достаточно изменить только предделитель, а если 800 Кбит/с, тогда только количество квантов для сегментов. Думаю всё понятно, и как и обещал всё просто. Вы сможете

Почему я писал что желательно чтоб частота APB1 была 32 или 16 МГц. Если указать частоту например 36 МГц, тогда мы получим вот такой результат…

Видно что Sample Point немного «уплывает», но это не критично, можно работать.

Далее нам нужно разобраться со следующим блоком настроек —

Basic Parameters

.

Time Triggered Communication Mode

— в этом документе, описывающим работу этого пункта, написано что это сложный в понимании (прям так и написано) механизм синхронизации узлов. Суть его примерно следующая: в обычном режиме у нас синхронизация происходит по стартовому биту, а если включить этот пункт тогда узел превращается в Time Master и с определённым интервалом (есть внутренний счётчик) начинает посылать в сеть сообщения (кадры), по которым другие узлы синхронизируются. Плюс к этому, вроде как устанавливаются временные рамки для передачи сообщений узлами. Точно я не могу сказать ибо сам не стал глубоко вникать в этот вопрос. Так же мне не понятно поддерживается ли это любыми CAN-сетями и устройствами. В общем я это не включаю.

Вот ещё пара документа на эту тему, кому какой лучше «зайдёт» )))

www.can-cia.org/fileadmin/resources/documents/proceedings/2006_fredriksson.pdf

www.cs.put.poznan.pl/wswitala/download/pdf/CiA2000Paper_1.pdf

Да, далее я буду называть кадры сообщениями, и наоборот.

Automatic Bus-Off Management — это важный и полезный пункт. У модуля CAN есть два счётчика ошибок —

Transmit Error Counter

(счетчик ошибок передачи) и

Receive Error Counter

(счетчик ошибок приема). При возникновении ошибки приёма Receive Error Counter увеличивается на единицу, при ошибке передачи Transmit Error Counter увеличивается сразу на 8

(видимо это объясняется тем, что отправка считается более важным действием)

. При успешном приёме или передаче соответствующий счётчик уменьшается на единицу. Если по причинам неисправности сети какой либо из счётчиков достигнет значения 255, модуль CAN перейдёт в состояние Bus-Off — ничего не передаёт и не отправляет в шину.

Если Automatic Bus-Off Management включён, тогда модуль CAN, будет автоматически восстанавливаться. Восстановление заключается в том, что модуль ждёт когда на шине будет «тишина» (рецессивное состояние) в течении времени, равное времени передачи 11 бит 128 раз подряд, и если всё окей, тогда включается в работу.

При скорости 500Kbit/s один бит передаётся за 2мкс. Значит чтобы шина восстановилась нужно чтоб линия находилась в рецессивном состоянии в течении 2.8 мс (128 * 11 * 2мкс = 2816мкс).

Если Automatic Bus-Off Management отключён, тогда надо «вручную» отлавливать момент перехода узла в состояние Bus-Off и переинициализировать его. В общем желательно включить этот пункт.

Automatic Wake-Up Mode — здесь всё понятно, если включено, то активность на шине разбудит спящий узел без дополнительных программностей (слово новое придумал)

Automatic Retransmission — если этот пункт включён, тогда узел будет повторять попытки отправить сообщение если не получает подтверждения приёма

(как вы помните, это инвертированный ACK-бит)

.

Если пункт отключён, тогда узел просто пульнёт сообщение, и если не получит подтверждение приёма, то не будет пытаться повторить отправку этого сообщения.

Вне зависимости от того, включён

Automatic Retransmission

или выключен, если передатчик не получает подтверждение приёма, выкидывается ошибка HAL_CAN_ERROR_ACK (не получил подтверждение приёма).

Если используется режим

Time Triggered Communication

(см. выше), тогда пункт

Automatic Retransmission

должен быть отключён.

Тут стоит сказать ещё пару слов: представим простую схему из двух узлов — один передаёт несколько разных кадров, другой их принимает. Если мы разорвём один любой провод шины (между трансиверами), тогда передатчик будет продолжать передавать, а приёмник будет принимать. То есть сигнал будет идти по

одному

проводу. Такая вот супер устойчивость CAN шины. Однако нюанс в том, что передатчик будет постоянно сыпать ошибкой HAL_CAN_ERROR_ACK. Это я к тому, что если повредите один провод, а система продолжит работу, то не удивляйтесь. При этом, если

Automatic Retransmission

включён, тогда передатчик будет долбить одним и тем же кадром, пытаясь повторить отправку.

Я провел этот эксперимент на линии длиной около полуметра. Как будут обстоять дела на длинных дистанциях не знаю.

В общем работа CAN шины весьма не проста.

Вот тут описана интересная, но невероятная, ситуация с Bus-Off и Automatic Retransmission.

Receive Fifo Locked Mode — у приёмника есть два независимых буфера (RX_FIFO_0 и RX_FIFO_1), можно пользоваться одним буфером или обоими. Какие сообщения будут попадать в нулевой или в первый буфер зависит от настроек фильтров (см. ниже). Каждый из буферов разделён на три ячейки называющиеся почтовыми ящиками (см. рис. ниже). Каждый почтовый ящик может хранить одно сообщение.

Если этот режим отключён, тогда если все ящики заполнены, а сообщения не вычитываются, последнее сообщение будет перезаписываться новым.

Если этот режим включён, тогда если все ящики заполнены, а сообщения не вычитываются, новые поступающие сообщения будут отбрасываться. То есть в ящиках будут оставаться старые сообщения.

Включить или отключить этот режим, решать вам, исходя из того что важнее.

Transmit Fifo Priority — у передатчика тоже есть буфер (один) разделённый на три почтовых ящика. Отправляемые сообщения помещаются в эти почтовые ящики, а оттуда уже улетают в сеть. Если слишком часто отправлять сообщения, то они будут накапливаться в этих ящиках.

Если режим включён, тогда сообщения улетают из ящиков в хронологическом порядке, то есть по принципу FIFO — первым пришёл, первым вышел.

Если режим отключён, тогда первыми улетают сообщения с более высоким приоритетом (как вы помните приоритет задаётся идентификатором). Таким образом, при очень интенсивной отправке сообщений может получится так, что сообщение с низким приоритетом никогда не будет отправлено, и так и будет валяться в своём ящике всё время.

Схема почтовых ящиков…

Сверху мы видим три почтовых ящика для отправки, которые управляются блоком Transmission Scheduler, и шесть почтовых ящиков для приёма. Active Core это грубо говоря сам интерфейс, Memory Access Controller разруливает трафик, а Acceptance Filters это аппаратные фильтры, которые пропускают или отбрасывают сообщения в зависимости от настроек этих самых фильтров, давая или не давая им попасть во входящие почтовые ящики.

Вся работа с почтовыми ящиками (кроме вычитывания входящих сообщений и отправки) происходит на аппаратном уровне.

И на конец последний пункт настройки —

Operating Mode

— режим работы или способ подключения.

Normal…

К плате подключён трансивер и она работает к полноценный узел в сети из двух и более устройств. То есть обычная работа.

Loopback…

Плата с трансивером будет передавать данные в шину и слушать себя же одновременно. Данные из шины получать не будет.

Silent…

Плата с трансивером получает данные из шины, но сама ничего не передаёт. Этот вариант подойдёт когда вам нужно почитать CAN-шину в автомобиле, и при этом ничего туда случайно не отправить.

Loopback combined with Silent…

Плата без трансивера. Все данные крутятся внутри МК. Этот режим подойдёт для тестирования программы при отсутствие трансивера и другого узла.

Теперь пришло время попрограммировать.

Поскольку наверняка не у всех читателей есть трансиверы под рукой, а попробовать хочется, мы вначале напишем программу для режима

Loopback combined with Silent

. Укажите его в настройках, остальное сделайте как на картинках и включите прерывания…

Прерывания для буфера RX_FIFO_0 (CAN RX0) будет вызываться когда прилетит кадр и пройдя через фильтры будет помещён в один из трёх почтовых ящиков. В какой именно ящик для нас не имеет значения, важно сразу же его прочитать, прямо в прерывании. Буфером RX_FIFO_1 мы не будем пользоваться, хватит и одного, позже мы вернёмся к этому вопросу.

Обратите внимание что у F103 (и у некоторых других камней) это прерывание пересекается с прерыванием от USB. Если вы планируете пользоваться USB, тогда включите прерывание для буфера RX_FIFO_1, буфером RX_FIFO_0 вы не будете пользоваться. Работе USB он не помешает.

Прерывание CAN SCE вызывается при возникновении ошибок.

Прерывание CAN TX вызывается когда кадр отправлен — оно нам не сильно интересно поэтому не включаем.

Объявляем глобально две структуры, два массива и переменную…

/* USER CODE BEGIN PV */
CAN_TxHeaderTypeDef TxHeader;
CAN_RxHeaderTypeDef RxHeader;
uint8_t TxData[8] = {0,};
uint8_t RxData[8] = {0,};
uint32_t TxMailbox = 0;

Структура TxHeader отвечает за отправку кадров, ниже мы её заполним.
Структура RxHeader для принятого кадра, из неё мы будем читать при приёме.
В массив TxData мы будем заносить полезные данные которые хотим передать.
В массиве RxData будут лежать полезные данные из принятого кадра.
С переменной TxMailbox ничего делать не нужно.

Добавляем колбек для приёма данных (для буфера RX_FIFO_0)…

/* USER CODE BEGIN 0 */
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
    if(HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RxData) == HAL_OK)
    {
        HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);	 
    }
}

При приёме любого кадра мы тут же забираем его из почтового ящика с помощью функции

HAL_CAN_GetRxMessage(…)

и мигаем светиком.

Если у вас настроено прерывание для буфера RX_FIFO_1, тогда колбек такой…

void HAL_CAN_RxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
    if(HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO1, &RxHeader, RxData) == HAL_OK)
    {
        HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);	 
    }
}

void HAL_CAN_RxFifo1… и CAN_RX_FIFO1.

И колбек для ошибок…

void HAL_CAN_ErrorCallback(CAN_HandleTypeDef *hcan)
{
    uint32_t er = HAL_CAN_GetError(hcan);
    sprintf(trans_str,"ER CAN %lu %08lX", er, er);
    HAL_UART_Transmit(&huart1, (uint8_t*)trans_str, strlen(trans_str), 100);
}

Перед бесконечным циклом заполняем структуру отвечающую за отправку кадров…

/* USER CODE BEGIN 2 */
TxHeader.StdId = 0x0378;
TxHeader.ExtId = 0;
TxHeader.RTR = CAN_RTR_DATA; //CAN_RTR_REMOTE
TxHeader.IDE = CAN_ID_STD;   // CAN_ID_EXT
TxHeader.DLC = 8;
TxHeader.TransmitGlobalTime = 0;

StdId

— это идентификатор стандартного кадра.

ExtId

— это идентификатор расширенного кадра. Мы будем отправлять стандартный поэтому сюда пишем 0.

RTR = CAN_RTR_DATA

— это говорит о том, что мы отправляем кадр с данными (Data Frame). Если указать CAN_RTR_REMOTE, тогда это будет Remote Frame.

IDE = CAN_ID_STD

— это говорит о том, что мы отправляем стандартный кадр. Если указать CAN_ID_EXT, тогда это будет расширенный кадр. В StdId нужно будет указать 0, а в ExtId записать расширенный идентификатор.

DLC = 8

— количество полезных байт передаваемых в кадре (от 1 до .

TransmitGlobalTime

— относится к Time Triggered Communication Mode, мы это не используем поэтому пишем 0.

Заполняем массив для отправки полезных данных каким-нибудь хламом…

for(uint8_t i = 0; i < 8; i++)
{
    TxData[i] = (i + 10);
}

Запускаем CAN…

HAL_CAN_Start(&hcan);

Если CANов несколько, тогда запускаем первый…

HAL_CAN_Start(&hcan1);

И активируем события которые будут вызывать прерывания…

HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING | CAN_IT_ERROR | CAN_IT_BUSOFF | CAN_IT_LAST_ERROR_CODE);

CAN_IT_RX_FIFO0_MSG_PENDING

— вызовет прерывание при получении сообщения в буфер CAN_RX_FIFO0. Колбек для этого мы прописали. Если используется буфер CAN_RX_FIFO1, тогда макрос такой — CAN_IT_RX_FIFO1_MSG_PENDING.

Если используются оба буфера, тогда так…

HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING | CAN_IT_RX_FIFO1_MSG_PENDING | CAN_IT_ERROR | CAN_IT_BUSOFF | CAN_IT_LAST_ERROR_CODE);

Остальное это прерывания из-за различных ошибок. Колбек для них мы тоже прописали. По большому счёту ошибки будут происходить только если что-то не в порядке с линией. Можно добавить в колбек мигалку красным светиком.

Вот все возможные события, которые можно добавить в функцию…

stm32f1xx_hal_can.h

И различные колбеки…

stm32f1xx_hal_can.c

Думаю что тут всё понятно из названий. Да и опять же, можно спокойно обходится без этих прерываний.

Теперь добавим один фильтр, который будет пропускать все сообщения. Хотя бы один фильтр должен быть настроен иначе работать не будет. Спускаемся вниз и находим функцию

static void MX_CAN_Init(void)

.

Добавляем в неё структуру для конфигурации фильтров…

/* USER CODE BEGIN CAN_Init 0 */
CAN_FilterTypeDef  sFilterConfig;
/* USER CODE END CAN_Init 0 */

И настройку фильтра…

/* USER CODE BEGIN CAN_Init 2 */
sFilterConfig.FilterBank = 0;
sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; 
sFilterConfig.FilterIdHigh = 0x0000;
sFilterConfig.FilterIdLow = 0x0000;
sFilterConfig.FilterMaskIdHigh = 0x0000;
sFilterConfig.FilterMaskIdLow = 0x0000;
sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
sFilterConfig.FilterActivation = ENABLE;
//sFilterConfig.SlaveStartFilterBank = 14;

if(HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE END CAN_Init 2 */

Подробно про фильтры будет рассказано в следующей части, а здесь только краткое пояснение.

У каждого модуля CAN есть 14 фильтров. У F103 один модуль CAN соответственно у него 14 фильтров с 0 по 13. Камни в которых есть два модуля CAN имеют в наличии 28 фильтров, с 0 по 13 для CAN_1, и с 14 по 28 для CAN_2. Каждый фильтр называется «банком» и имеет порядковый номер. В данном случае мы используем банк-фильтр номер 0 (первый элемент структуры).

Пропускаем несколько элементов

(в них записываются идентификаторы кадров, которые нужно принять)

и видим что в элемент FilterFIFOAssignment мы записали макрос CAN_RX_FIFO0. Это значит что фильтр будет работать с буфером RX_FIFO_0. Поскольку мы не настроили никаких фильтров для буфера RX_FIFO_1, он не будет принимать участия в работе, все сообщения будут приходить только в буфер RX_FIFO_0. Если вы настраивали прерывание для буфера RX_FIFO_1, тогда в FilterFIFOAssignment нужно записать CAN_RX_FIFO1.

Чтобы задействовать оба буфера нужно настроить хотя бы два фильтра для разных идентификаторов и тогда можно будет в один буфер пропускать одни сообщения, а в другой другие. Тогда будет смысл в использовании обоих буферов.

В конце вызывается функция конфигурации фильтра.

В результате функция инициализации CAN будет выглядеть так…

static void MX_CAN_Init(void)
{
  /* USER CODE BEGIN CAN_Init 0 */
  CAN_FilterTypeDef  sFilterConfig;
  /* USER CODE END CAN_Init 0 */

  /* USER CODE BEGIN CAN_Init 1 */

  /* USER CODE END CAN_Init 1 */
  hcan.Instance = CAN1;
  hcan.Init.Prescaler = 4;
  hcan.Init.Mode = CAN_MODE_NORMAL;
  hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
  hcan.Init.TimeSeg1 = CAN_BS1_13TQ;
  hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
  hcan.Init.TimeTriggeredMode = DISABLE;
  hcan.Init.AutoBusOff = ENABLE;
  hcan.Init.AutoWakeUp = DISABLE;
  hcan.Init.AutoRetransmission = ENABLE;
  hcan.Init.ReceiveFifoLocked = DISABLE;
  hcan.Init.TransmitFifoPriority = ENABLE;
  if (HAL_CAN_Init(&hcan) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN CAN_Init 2 */
  sFilterConfig.FilterBank = 0;
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; 
  sFilterConfig.FilterIdHigh = 0x0000;
  sFilterConfig.FilterIdLow = 0x0000;
  sFilterConfig.FilterMaskIdHigh = 0x0000;
  sFilterConfig.FilterMaskIdLow = 0x0000;
  sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
  sFilterConfig.FilterActivation = ENABLE;
  //sFilterConfig.SlaveStartFilterBank = 14;

  if(HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE END CAN_Init 2 */

}

И на конец последнее что нужно сделать, это добавить в бесконечный цикл отправку сообщений…

/* USER CODE BEGIN WHILE */
while (1)
{
	while(HAL_CAN_GetTxMailboxesFreeLevel(&hcan) == 0);

	if(HAL_CAN_AddTxMessage(&hcan, &TxHeader, TxData, &TxMailbox) != HAL_OK)
	{
		HAL_UART_Transmit(&huart1, (uint8_t*)"ER SENDn", 8, 100);
	}
	
	HAL_Delay(500);
}

Функция

HAL_CAN_GetTxMailboxesFreeLevel(…)

возвращает количество свободных ящиков для отправки (как вы помните у нас их три), то есть она должна вернуть 1, 2 или 3. Если все ящики заняты (сообщения не успели улететь) тогда будет возвращаться 0. Соответственно мы тормозим программу пока не освободится хотя бы один ящик.

Функция

HAL_CAN_AddTxMessage(…)

отправляет сообщение в почтовый ящик (оттуда оно улетает автоматически). Аргументами мы передаём структуру в которой у нас записаны настройки сообщения (идентификатор и т.д.), и массив с полезными данными. Последний аргумент нам не интересен.

Собственно это всё, можно прошивать. Плата будет сама себе отправлять сообщения, а светик будет мигать в колбеке приёма.

Чтобы было немного интереснее, будем передавать сообщения с разными идентификаторами и менять нулевой элемент в массиве с полезными данными…

/* USER CODE BEGIN WHILE */
while (1)
{
	TxHeader.StdId = 0x0378;
	TxData[0] = 90;

	while(HAL_CAN_GetTxMailboxesFreeLevel(&hcan) == 0);

	if(HAL_CAN_AddTxMessage(&hcan, &TxHeader, TxData, &TxMailbox) != HAL_OK)
	{
		HAL_UART_Transmit(&huart1, (uint8_t*)"ER SENDn", 8, 100);
	}

	HAL_Delay(500);


	TxHeader.StdId = 0x0126;
	TxData[0] = 100;

	while(HAL_CAN_GetTxMailboxesFreeLevel(&hcan) == 0);

	if(HAL_CAN_AddTxMessage(&hcan, &TxHeader, TxData, &TxMailbox) != HAL_OK)
	{
		HAL_UART_Transmit(&huart1, (uint8_t*)"ER SENDn", 8, 100);
	}

	HAL_Delay(500);

/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
}

В колбеке будем проверять идентификаторы и выводить инфу в USART…

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
    if(HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RxData) == HAL_OK)
    {
        HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);

        if(RxHeader.StdId == 0x0378)
        {
        	snprintf(trans_str, 128, "ID %04lX %dn", RxHeader.StdId, RxData[0]);
        	HAL_UART_Transmit(&huart1, (uint8_t*)trans_str, strlen(trans_str), 100);
        }
        else if(RxHeader.StdId == 0x0126)
        {
        	snprintf(trans_str, 128, "ID %04lX %dn", RxHeader.StdId, RxData[0]);
        	HAL_UART_Transmit(&huart1, (uint8_t*)trans_str, strlen(trans_str), 100);
        }
    }
}

Если у вас есть две платы с трансиверами, тогда можете настроить режим Normal…

И залить этот проект в обе платы — они начнут обмениваться данными между собой. Только пропишите разные идентификаторы для отправки для разных плат, в бесконечном цикле.

Статья получилась большая поэтому описание настройки фильтров и использование двух CAN модулей на одном камне в следующей части.

Проект на Github.

Это всё, всем спасибо

Телеграм-чат istarik

Телеграм-чат STM32

Базовое расширенное периферийное устройство CAN (Basic Extended CAN, которое сокращенно называется bxCAN), позволяет подключить MCU STM32 с сети CAN. Поддерживаются CAN протоколы версий 2.0A и 2.0B. Контролер CAN был разработан для эффективного обслуживания большого количества входящих сообщений с минимальной нагрузкой на вычислительное ядро CPU. Также он удовлетворяет требованиям приоритета для передачи сообщений.

Примечание: информация в этой статье (перевод раздела «32 Controller area network (bxCAN)» даташита [1]) относится ко всем представителям MCU семейства STM32F4xx, если специально не указано что-то иное.

В критически важных для безопасности приложениях контроллер CAN предоставляет все аппаратные функции для поддержки опции обмена CAN Time Triggered Communication.

Основные функции и возможности bxCAN:

• Имеется два интерфейса CAN: CAN1 и CAN2.
• Поддерживается протокол CAN версий 2.0A, B Active.
• Скорости до 1 мегабит/сек.
• Поддерживается опция Time Triggered Communication.

Передача:

• 3 передающих mailbox.
• Конфигурируемый приоритет передачи.
• Метка времени (Time Stamp) на передаче SOF.

Прием:

• 2 принимающих FIFO с тремя уровнями.
• Масштабируемые банки фильтра: 28 банков фильтра, используемые совместно CAN1 и CAN2.
• Функция идентификатора списка.
• Конфигурируемый порог переполнения FIFO (FIFO overrun).
• Метка времени (Time Stamp) на приеме SOF.

Опция коммуникации Time-triggered:

• Запрет режима автоматической ретрансмиссии.
• 16-разрядный свободно считающий таймер.
• Метка времени (Time Stamp) в последних двух байтах данных.

Управление:

• Маскируемые прерывания.
• Эффективное для программы отображение mailbox на уникальный адрес.

Одновременная работа двух CAN (Dual CAN):

• CAN1: Master bxCAN для управления коммуникацией между Slave bxCAN и 512 байтами памяти SRAM.
• CAN2: Slave bxCAN, без прямого доступа к памяти SRAM.
• Два bxCAN используют общую память 512 байт SRAM (см. рис. 335).

Рис. 335. Блок-схема Dual CAN.

Примечание: начальный банк фильтров CAN2 номер n конфигурируется записью CAN2SB[5:0] бит в регистре CAN_FMR.

[Общее описание bxCAN]

В современных приложениях CAN количество узлов сети увеличивается, и часто сети соединяются друг с другом через шлюзы (gateway). Обычно количество сообщений в системе (и таким образом обрабатываемых каждым узлом) значительно увеличивается. В дополнение к сообщениям приложения были введены сообщения управления сетью и диагностики (Network Management and Diagnostic messages).

• Для обработки каждого типа сообщения требуется расширенный механизм фильтрации.

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

• Схема FIFO приема позволяет переключить CPU на задачи приложения на долгое время без потери принимаемых сообщений.

Стандартный высокоуровневый протокол HLP (аббревиатура от Higher Layer Protocol), основанный на стандартных драйверах CAN, требует эффективного интерфейса с контроллером CAN.

Рис. 334. Топология сети CAN.

Активное ядро CAN 2.0B. Модуль bxCAN полностью автономно обрабатывает передачу и прием сообщений CAN. Стандартные идентификаторы (11 бит) и расширенные идентификаторы (29 бит) полностью поддерживаются аппаратурой контроллера.

Регистры управления, статуса и конфигурации. Приложение использует эти регистры для следующих целей:

• Конфигурирования параметров CAN, например скорости передачи/приема (baud rate).
• Запрос передач.
• Обработка приема.
• Управление прерываниями.
• Получение информации диагностики.

Передающие ящики (Tx mailboxes). Предоставлены 3 передающих mailbox, чтобы настраивать отправку сообщений. Планировщик передачи (transmission Scheduler) принимает решение, какой mailbox должен быть передан первым.

Фильтры приема (Acceptance filters). bxCAN предоставляет 28 масштабируемых / конфигурируемых банков фильтров по идентификатору, чтобы выделять из принимаемых данных нужные сообщения и отбрасывать другие.

FIFO приема. Для сохранения поступающих сообщений используются 2 приемных FIFO. В каждом FIFO можно сохранить 3 полных сообщения. FIFO полностью обслуживаются аппаратурой контроллера CAN.

[Рабочие режимы bxCAN]

У bxCAN есть 3 основных рабочих режима: initialization (инициализация), normal (активная работа) и Sleep (сон, приостановка). После аппаратного сброса bxCAN находится в режиме Sleep, чтобы снизить потребление энергии, и на CANTX активен внутренний pull-up (верхний подтягивающий резистор). Программа запрашивает bxCAN на вход в режим initialization или Sleep установкой бит INRQ или SLEEP в регистре CAN_MCR. Как только произошел вход в режим, bxCAN подтверждает это установкой бит INAK или SLAK в регистре CAN_MSR, и внутренний pull-up запрещается. Когда ни один из бит INAK и SLAK не установлен, bxCAN находится в режиме normal. Перед входом в режим normal bxCAN всегда должен быть синхронизирован с шиной CAN. Для синхронизации bxCAN ждет, пока шина CAN не освободится (перейдет в состояние idle), это означает, что отслеживается появление 11 следующих друг за другом рецессивных бита на сигнале CANRX.

Режим инициализации. Программная инициализация может быть осуществлена, когда железо CAN находится в режиме инициализации (Initialization mode). Чтобы войти в этот режим, программа устанавливает бит INRQ в регистре CAN_MCR и ждет, пока железо подтвердит этот запрос установкой бита INAK в регистре статуса CAN_MSR.

Чтобы покинуть режим инициализации, программа очищает бит INQR. bxCAN покинет режим инициализации, когда бит INAK очистится аппаратурой.

Во время режима инициализации останавливаются все входящие и исходящие транзакции сообщений CAN, и статус шины CAN на выходе CANTX сохраняется рецессивным (лог. 1).

Вход в режим инициализации не меняет ни один регистр конфигурации.

Чтобы инициализировать контроллер CAN, программа должна установить длительность бита (Bit Timing, регистр CAN_BTR) и опции CAN (регистр управления CAN_MCR).

Чтобы инициализировать регистры, связанные с банками фильтров CAN (mode, scale, FIFO assignment, activation и значения фильтраand filter values), программа должна установить бит FINIT (в регистре CAN_FMR). Инициализация фильтра также может быть осуществлена вне режима инициализации.

Примечание: когда FINIT=1, прием CAN деактивирован. Значения фильтра также можно модифицировать сбросом соответствующих бит активации (в регистре CAN_FA1R). Если банк фильтра не используется, то рекомендуется оставить его в неактивном режиме (т. е. оставить его соответствующий бит FACTx очищенным).

Нормальный режим (normal mode). Как только инициализация завершена, программа должна запросить у аппаратуры вход в нормальный режим, чтобы она могла засинхронизироваться с шиной CAN, и начать прием и передачу.

Запрос входа в Normal mode выдается очисткой бита INRQ в регистре управления CAN_MCR. Блок bxCAN входит в режим Normal и готов принять участие в активности на шине, когда он синхронизирован с передачей данных по шине CAN. Это осуществляется ожиданием появления на шине 11 следующих друг за другом рецессивных бит (состояние ожидания Bus Idle). Переключение в Normal mode подтверждается аппаратурой, когда она сбрасывает бит INAK в регистре статуса CAN_MSR.

Инициализация значений фильтра не зависит от режима инициализации, однако должна осуществляться, когда инициализируемый фильтр не активен (его соответствующий бит FACTx сброшен). Параметры фильтра scale и mode должны конфигурироваться перед входом в режим Normal.

Режим Sleep (малое потребление мощности). Чтобы уменьшить энергопотребление, у bxCAN есть режим пониженного потребления мощности (low-power mode), который называется режим сна (Sleep mode). В этот режим осуществляется вход по запросу программы установкой бита SLEEP в регистре CAN_MCR. В этом режиме тактирование bxCAN останавливается, однако программа все еще имеет доступ к ящикам (mailboxes) bxCAN.

Если программа запрашивает вход в режим инициализации установкой бита INRQ, когда bxCAN находится в Sleep mode, она также должна очистить бит SLEEP.

Блок bxCAN может быть разбужен (выведен из Sleep mode) либо программно путем очистки бита SLEEP, или когда была детектирована активность шины CAN.

Когда была определена активность на шине CAN, аппаратура автоматически выполняет последовательность пробуждения очисткой бита SLEEP, если установлен бит AWUM в регистре CAN_MCR. Если бит AWUM очищен, то программа должна очистить бит SLEEP, когда произошло прерывание пробуждения (wakeup interrupt), чтобы bxCAN вышел из Sleep mode.

Примечание: если разрешено прерывание пробуждения (wakeup interrupt, установлен бит WKUIE в регистре CAN_IER), то будет генерироваться прерывание пробуждения, когда была определена активность шины CAN, даже если bxCAN автоматически выполняет последовательность пробуждения.

После того, как бит SLEEP был очищен, произойдет выход из Sleep mode, когда bxCAN засинхронизировался с шиной CAN, см. рис. 336. Из режима Sleep mode произойдет выход, когда аппаратура очистила бит SLAK.

Рис. 336. Режимы bxCAN.

Примечания:

(1) ACK = состояние ожидания (wait state), во время которого аппаратура подтверждает запрос установкой бит INAK или SLAK в регистре CAN_MSR.
(2) SYNC = состояние, во время которого bxCAN ожидает состояния ожидания шины CAN (idle state, когда прошло 11 следующих друг за другом рецессивных бита на CANRX).

[Режим тестирования]

Режим тестирования может быть выбран битами SILM и LBKM в регистре CAN_BTR. Эти биты должны быть сконфигурированы, когда bxCAN находится в Initialization mode. Как только был выбран режим тестирования, для входа в режим Normal должен быть сброшен бит INRQ в регистре CAN_MCR.

Silent mode. Блок bxCAN может быть переведен в «тихий режим» (Silent mode) установкой бита SILM в регистре CAN_BTR.

В тихом режиме bxCAN может принимать правильные фреймы данных и правильные фреймы remote, однако bxCAN передает только рецессивные биты на шине CAN, и не может начать передачу. Если bxCAN должен отправить доминантный бит (бит ACK, флаг overload, флаг active error), то бит перемашрутизируется внутри таким образом, что ядро CAN мониторит этот доминантный бит, хотя шина CAN может оставаться в рецессивном состоянии. Silent mode может использоваться для анализа трафика на шине CAN без влияния на шину передачей доминантных бит (доминантные биты Acknowledge, фреймы ошибки Error Frame физически не передаются).

Рис. 337. Блок bxCAN в Silent Mode.

Loop back mode. Блок bxCAN может быть установлен в режим зацикливания (Loop Back Mode) установкой бита LBKM в регистре CAN_BTR. В Loop Back Mode блок bxCAN обрабатывает свои собственные передаваемые сообщения как принимаемые, и сохраняет их (если они прошли фильтрацию, acceptance filtering) в ящиках приема (Receive mailbox).

Рис. 338. Блок bxCAN в режиме зацикливания.

Этот режим предоставлен для функций самотестирования. Чтобы быть независимым от внешних событий, ядро CAN игнорирует ошибки подтверждения (acknowledge errors, отсутствие доминантного бита, оцифрованного в слоте подтверждения данных фрейма data / remote), в режиме Loop Back. В этом режиме bxCAN соединяет выход Tx со входом Rx внутри чипа. Актуальное значение входа на выводе CANRX игнорируется блоком bxCAN. Передаваемые сообщения могут мониториться на выводе CANTX.

Комбинация режимов Loop back и silent. Можно также скомбинировать режимы Loop Back и Silent установкой бит LBKM и SILM в регистре CAN_BTR. Это может использоваться для «горячего самотестирования», т. е. bxCAN может быть проверен в режиме Loop Back, но без влияния на работающую систему CAN, подключенную к выводам CANTX и CANRX. В этом режиме вывод CANRX отключен от bxCAN, и вывод CANTX удерживается в рецессивном состоянии.

Рис. 339. Блок bxCAN в комбинированном режиме.

[Debug mode]

Когда MCU вошел в отладочный режим debug mode (приостановлено ядро Cortex®-M4 с FPU), блок bxCAN продолжит нормально работать или останавливается, в зависимости от:

• Бита DBG_CAN1_STOP для CAN1 или бита DBG_CAN2_STOP для CAN2 в модуле DBG. Для получения подробностей см. секцию «38.16.2 Debug support for timers, watchdog, bxCAN and I2C» даташита [1].
• Бита DBF в регистре CAN_MCR. Для дополнительной информации см. секцию 32.9.2 даташита [1].

[Функциональное описание bxCAN]

Обработка передачи. Чтобы передать сообщение, приложение должно выбрать пустой transmit mailbox, установить идентификатор, код длины данных (data length code, DLC) и передаваемые данные перед тем, как запросить передачу установкой соответствующего бита TXRQ в регистре CAN_TIxR. Как только mailbox покинул состояние опустошенности (empty state), программа больше не может получить доступ на запись в его регистры. Сразу после установки бита TXRQ mailbox входит в состояние ожидания отправки (enters pending), и ждет, когда он станет самым приоритетным для передачи, см. врезку «Приоритет передачи». Как только mailbox получил самый высокий приоритет, он будет запланирован на передачу. Передача сообщения запланированного mailbox начнется (произойдет вход в состояние передачи), когда шина CAN окажется в состоянии ожидания (idle). Как только mailbox был успешно передан, он снова станет пустым (empty). Аппаратура покажет успешную передач установкой бит RQCP и TXOK в регистре CAN_TSR.

Если передача была неудачной, то это состояние будет показано битом ALST в регистре CAN_TSR, когда был проигрыш арбитража (Arbitration Lost), и/или битом TERR, когда была детектирована ошибка передачи.

Обрыв передачи. Запрос на передачу может быть оборван (abort) пользователем путем установки бита ABRQ в регистре CAN_TSR. Когда mailbox находится в состоянии pending или scheduled обрыв произойдет немедленно. Когда запрос на abort поступил в состоянии передачи mailbox, то состояние передачи может иметь одно из 2 результатов. Если была успешная передача, то mailbox станет пустым с установкой бита TXOK в регистре CAN_TSR. Если передача была неудачной, то mailbox получит состояние запланированности на передачу (scheduled), передача оборвется и ящик станет пустым с очищенным TXOK. Во всех случаях ящик становится пустым, как минимум в конце текущей передачи.

Режим не автоматической повторной передачи. Этот режим был реализован, чтобы удовлетворить требованиям опции Time Triggered Communication стандарта CAN. Чтобы сконфигурировать аппаратуру в этот режим, должен быть установлен бит NART в регистре CAN_MCR.

В этом режиме каждая передача начинается только однократно. Если первая попытка потерпела неудачу из-за потери арбитража или из-за ошибки, аппаратура не будет автоматически перезапускать передачу сообщения.

По окончании первой попытки передачи, аппаратура считает запрос завершенным, и установит бит RQCP в регистре CAN_TSR. Результат передачи показывается в регистре CAN_TSR битами TXOK, ALST и TERR.

Рис. 340. Состояния передающего mailbox.

Режим Time Triggered Communication. В этом режиме активируется внутренний счетчик аппаратуры CAN и используется для генерации значения метки времени (Time Stamp), сохраняемой в регистрах CAN_RDTxR/CAN_TDTxR (соответственно для Rx и Tx mailbox). Внутренний счетчик инкрементируется на каждом битовом интервале CAN, см. далее секцию «Интервалы бит (bit timing)». Внутренний счетчик захватывается в точке оцифровки (sample point) бита начала фрейма (Start Of Frame, SOF) и для приема, и для передачи.

[Обработка приема]

Для приема сообщений CAN предоставляются три mailbox, организованных как FIFO. Чтобы уменьшить нагрузку на CPU, упростить программу и гарантировать целостность данных, FIFO полностью обслуживается аппаратурой. Приложение обращается к сохраненным в FIFO сообщениям через выходной mailbox FIFO.

Корректно принятое сообщение. Принятое сообщение считается корректным (valid), когда оно было правильно принято в соответствии с протоколом CAN (не было ошибки до последнего бита, но с одним битом в поле EOF), и при этом успешно прошло фильтрацию по идентификатору (см. далее секцию «Фильтрация по идентификатору»).

Рис. 341. Состояния приемного FIFO.

Обслуживание FIFO. Начиная с состояния «пусто» (empty) FIFO, первое корректно принятое сообщение сохраняется в FIFO, который переходит в состояние pending_1 (ожидает обработки одно принятое сообщение). Аппаратура сигнализирует об этом событии установкой бит FMP[1:0] в регистре CAN_RFR в значение 01b. Сообщение становится доступным в выходном mailbox FIFO. Программа считывает текущий mailbox и освобождает его установкой бита RFOM в регистре CAN_RFR. После этого FIFO снова становится пустым. Если в этот момент было принято новое корректное сообщение, то FIFO остается в состоянии pending_1, и новое сообщение доступно в выходном mailbox FIFO.

Если программа не освободила mailbox, то следующее корректно принятое сообщение будет сохранено в FIFO, который перейдет в состояние pending_2 (FMP[1:0] = 10b). Процесс сохранения сообщений в FIFO продолжится вплоть до перехода FIFO в состояние pending_3 (FMP[1:0] = 11b). В этой точке программа должна освободить выходной mailbox FIFO установкой бита RFOM, чтобы можно было освободить mailbox для сохранения нового корректного сообщения. Иначе следующее корректное сообщение будет потеряно. См. также раздел «Хранилище сообщений».

Overrun. Как только FIFO перешел в состояние pending_3 (т. е. все mailbox заполнены), следующее поступившее сообщение приведет к переполнению приема (overrun), и сообщение будет потеряно. Аппаратура сигнализирует о состоянии overrun установкой бита FOVR в регистре CAN_RFR. Какое сообщение потеряно, зависит от конфигурации FIFO:

• Если функция блокировки FIFO (FIFO lock) запрещена (очищен бит RFLM в регистре CAN_MCR), то последнее сохраненное сообщение в FIFO будет перезаписано новым поступившим сообщением. В этом случае последние поступившие (самые свежие) сообщения будут всегда доступны для приложения.
• Если функция блокировки FIFO разрешена (установлен бит RFLM в регистре CAN_MCR), то самое свежее поступившее сообщение будет отброшено, и для программы будут всегда доступны 3 самые старые не обработанные сообщения FIFO.

Прерывания приема. Как только сообщение было сохранено в FIFO, обновятся биты FMP[1:0] и генерируется запрос прерывания, если установлен бит FMPIE в регистре разрешения прерываний CAN_IER.

Когда FIFO становится заполненным (т. е. сохранено третье сообщение), установится бит FULL в регистре CAN_RFR, и будет сгенерировано прерывание, если установлен бит FFIE в регистре разрешения прерываний CAN_IER.

При переполнении приема (overrun condition) установится бит FOVR, и будет сгенерировано прерывание, если установлен бит FOVIE в регистре разрешения прерываний CAN_IER.

[Фильтрация по идентификатору]

В протоколе CAN идентификатор сообщения не связан с адресом узла, но связан с содержимым сообщения. Следовательно, передатчик передает свое сообщение всем приемникам. Во время приема сообщения принимающий узел решает — в зависимости от значения идентификатора — нуждается программа в этом сообщении, или нет. Если сообщение нужное, то оно копируется в SRAM. Если нет, то сообщение будет отброшено без какого-либо вмешательства со стороны программы.

Чтобы удовлетворить этому требованию, контроллер bxCAN предоставляет для приложения 28 конфигурируемых и масштабируемых банков фильтра (27 .. 0). Эта аппаратная фильтрация сохраняет процессорное время CPU, которое иначе тратилось бы, если фильтрация была реализована программно. Каждый банк фильтра x состоит из двух 32-битных регистра CAN_FxR0 и CAN_FxR1.

Масштабируемая ширина (scale). Чтобы оптимизировать и адаптировать фильтрацию к требованиям приложения, каждый банк фильтра может масштабироваться независимо. В зависимости от масштаба фильтра банк фильтра предоставляет (см. рис. 342):

• Один 32-битный фильтр для бит STDID[10:0], EXTID[17:0], IDE и RTR.
• Два 16-битных фильтра для бит STDID[10:0], RTR, IDE и EXTID[17:15].

Кроме того, фильтры могут быть сконфигурированы в режиме маски (mask mode) или в режиме списка идентификаторов (identifier list mode).

Mask mode. В режиме маски регистры идентификатора связаны с регистрами маски, указывающими, какие биты в идентификаторе должны совпадать (must match), а какие могут быть любыми (don’t care).

Identifier list mode. В режиме списка идентификаторов регистры маски используются как регистры идентификатора. Таким образом, вместо определения идентификатора и маски, указываются 2 идентификатора, удваивая количество одиночных идентификаторов. Все биты приходящего идентификатора должны совпадать с битами, указанными в регистрах фильтра.

Конфигурация scale и mode банка фильтра. Банки фильтра конфигурируются соответствующим регистром CAN_FMR. Для конфигурирования банка фильтра он должен быть деактивирован очисткой бита FACT в регистре CAN_FAR. Параметр scale фильтра конфигурируется соответствующим битом FSCx регистра CAN_FS1R, см. рис. 342. Режим маски или режим списка идентификаторов для соответствующих регистров Mask/Identifier конфигурируется битами FBMx в регистре CAN_FMR.

Для фильтрации группы идентификаторов сконфигурируйте регистры Mask/Identifier в режиме маски.

Для выбора одиночных идентификаторов сконфигурируйте регистры Mask/Identifier в режиме списка идентификаторов.

Фильтры, не используемые приложением, должны быть оставлены деактивированными.

Каждый фильтр в банке фильтра пронумерован (номер называется Filter Number) от 0 до максимума, в зависимости от mode и scale каждого банка фильтра.

Конфигурация фильтра показана на рис. 342.

Рис. 342. Конфигурация масштабирования (scale) банков фильтра — организация регистров.

Примечания:

x = номеру банка фильтра.
ID = идентификатору.
(1) Эти биты находятся в регистре CAN_FS1R.
(2) Эти биты находятся в регистре CAN_FM1R.

Индекс совпадения фильтра. Как только сообщение было принято в FIFO, оно становится доступным для приложения. Обычно данные приложения копируются в ячейки SRAM. Чтобы копировать данные в правильное место, приложение должно идентифицировать данные по идентификатору. Чтобы упросить доступ к ячейкам SRAM принятых сообщений, контроллер CAN предоставляет индекс совпадения фильтра (Filter Match Index).

Этот индекс сохраняется в mailbox вместе с сообщением, в соответствии с правилами приоритета фильтра. Таким образом, каждое принятое сообщение связывает с индексом совпадения фильтра.

Индекс Filter Match может быть задействован двумя способами:

• Сравнение индекса Filter Match со списком ожидаемых значений.
• Использование индекса Filter Match как индекса в массиве для доступа к месту нахождения данных.

Для не маскируемых фильтров программа больше не должна сравнивать идентификатор.

Если фильтр маскирован, то программа ограничивает сравнение только маскированными битами.

Значение индекса номера фильтра не учитывает состояние активации банков фильтра. Дополнительно используются две независимые схемы нумерации, по одной для каждого FIFO. Пример см. на рис. 343.

Рис. 343. Пример нумерации фильтров. ID означает идентификатор.

Правила приоритезации фильтра. В зависимости от комбинации фильтров может произойти ситуация, когда идентификатор пройдет через несколько фильтров. В этом случае значение выбранного совпавшего фильтра сохраняется в mailbox приема по следующим правилам приоритета:

• 32-битный фильтр имеет приоритет над 16-битным фильтром.
• Для фильтров с одинаковым scale, приоритет предоставляется режиму списка идентификаторов (Identifier List mode) над режимом маски идентификаторов (Identifier Mask mode).
• Для фильтров с одинаковым scale и mode, приоритет дается по номеру фильтра (чем меньше номер, тем выше приоритет).

Рис. 344. Пример механизма фильтрации. Три банка фильтра сконфигурированы в 32-битном Unidentified List mode, остальные в 32-битном Identifier Mask mode.

На рис. 344 выше показан пример принципа фильтрации bxCAN. На приеме сообщения идентификатор сначала сравнивается с фильтрами, сконфигурированными в identifier list mode. Если было совпадение, то сообщение сохранятся в связанном FIFO и индекс совпавшего фильтра сохраняется в Filter Match Index (FMI). Как показано в примере, идентификатор совпал с Identifier #2, так что в FIFO будет сохранено содержимое сообщения и FMI 2.

Если не было совпадения, пришедший идентификатор сравнивается с фильтрами, сконфигурированными в mask mode.

Если идентификатор не совпал ни с одним из идентификаторов, сконфигурированным в фильтрах, то сообщение отбрасывается аппаратно, никак не влияя на программу.

[Хранилище сообщений]

Интерфейс между программой и аппаратурой для сообщений CAN реализован через ящики (mailboxes). Mailbox содержит всю информацию, относящуюся к сообщению: идентификатор, данные, управление, статус и метку времени.

Transmit mailbox. Программа настраивает сообщение для передачи в пустом передающем mailbox. Статус передачи показывается аппаратурой в регистре CAN_TSR.

Таблица 182. Отображение ящиков передачи (TX mailbox) передачи.

Receive mailbox. Когда было принято сообщение, оно становится доступным в выходном mailbox FIFO. Когда программа обработала сообщение (т. е. прочитала его), она должна освободить выходной mailbox FIFO с помощью бита RFOM в регистре CAN_RFR, чтобы стало доступным для чтения следующее приходящее сообщение. Индекс совпавшего фильтра сохраняется в поле MFMI регистра CAN_RDTxR. 16-битное значение метки времени (time stamp) сохраняется в поле TIME[15:0] регистра CAN_RDTxR.

Таблица 183. Отображение ящиков (RX mailbox) приема.

[Обработка ошибок]

Обработка ошибок (error management), как это описано в протоколе CAN, осуществляется полностью аппаратно, с использованием счетчика ошибок передачи Transmit Error Counter (значение TEC в регистре CAN_ESR) и счетчика ошибок приема Receive Error Counter (значение REC в регистре CAN_ESR), которые инкрементируются по мере появления событий ошибки. Более подробно обслуживание TEC и REC описано в стандарте CAN.

Оба счетчика TEC и REC могут быть прочитаны программой, чтобы определить стабильность сети CAN. Кроме того, аппаратура CAN предоставляет подробную информацию о текущем статусе ошибки в регистре CAN_ESR. Через регистр CAN_IER (бит ERRIE и т. п.), программа может очень гибко сконфигурировать прерывание при детектировании ошибки.

Рис. 345. Диаграмма состояний ошибки CAN.

Восстановление из Bus-Off. Состояние Bus-Off (отключение от шины) достигается, когда TEC становится больше 255, это состояние индицируется битом BOFF регистра CAN_ESR. В состоянии Bus-Off блок bxCAN больше не может передавать и принимать сообщения.

В зависимости от бита ABOM в регистре CAN_MCR, блок bxCAN будет восстанавливаться из Bus-Off (переходить в состояние error active) либо автоматически, либо по запросу программы. Однако в обоих случаях bxCAN будет ждать как минимум последовательности восстановления (recovery sequence), описанную в стандарте CAN (128 случаев появления 11 следующих друг за другом рецессивных бит, обнаруженных на CANRX).

Если установлен ABOM, то bxCAN автоматически начнет последовательность восстановления после того, как произошел вход в состояние Bus-Off. Если ABOM очищен, то программа должна инициировать последовательность восстановления путем запроса к bxCAN на вход в режим инициализации и на выход из него.

Примечание: в режиме инициализации bxCAN не мониторит сигнал CANRX, поэтому не может завершить последовательность восстановления. Для восстановления bxCAN должен быть в normal mode.

[Интервалы бит (bit timing)]

Логика тайминга бита мониторит последовательную линию шины и выполняет оцифровку сигнала с подстройкой точки выборки. Это делается синхронизацией по перепаду начального бита, и повторной синхронизацией на последующих перепадах.

Эта операция может быть объяснена простым разделением номинального времени бита на 3 сегмента следующим образом:

• Сегмент синхронизации (SYNC_SEG): во время этого интервала времени ожидается изменение бит. Величина этого сегмента фиксируется на одном кванте времени (time quantum): 1 x t_q.
• Сегмент бита 1 (Bit segment 1, BS1): определяет положение точки выборки уровня сигнала (sample point). Стандарт включает сюда интервалы PROP_SEG (сегмент распространения) и PHASE_SEG1 (сегмент фазы 1). Длительности этих интервалов программируются между 1 и 16 time quanta, однако они могут быть автоматически увеличены для компенсации положительного дрейфа фазы из-за разницы частот тактов различных узлов в сети.
• Сегмент бита 2 (Bit segment 2, BS2): определяет положение точки передачи (transmit point). Представлен в стандарте CAN интервалом PHASE_SEG2 (сегмент фазы 2). Его длительность программируется в диапазоне от 1 до 8 time quanta, однако этот интервал может быть автоматически сокращен для компенсации отрицательных смещений фазы.

Параметр ширины скачка ресинхронизации (resynchronization Jump Width, SJW) определяет верхнюю границу величины удлинения или укорочения сегментов бита. Программируется в диапазоне от 1 до 4 time quanta.

Достоверный перепад детектируется как первый переход в интервале бита от доминантного к рецессивному уровню шины при условии, что контролер сам не передает рецессивный бит.

Если достоверный перепад был детектирован в BS1 вместо SYNC_SEG, BS1 расширяется на интервал SJW, чтобы точка выборки была задержана. Соответственно, если достоверный перепад был определен в интервале BS2 вместо SYNC_SEG, интервал BS2 укорачивается на SJW, чтобы точка передачи оказалась раньше.

В качестве защиты от ошибок программирования конфигурация Bit Timing Register (CAN_BTR) возможна только когда устройство находится в режиме Standby.

Примечание: подробное описание тайминга бит CAN и механизма ресинхронизации см. в стандарте ISO 11898.

Рис. 346. Интервалы бит.

                  1
BaudRate = —————-
            NominalBitTime

NominalBitTime = 1 x t_q + t_BS1 + t_BS2

Здесь:

t_BS1 = t_q x (TS1[3:0] + 1),
t_BS2 = t_q x (TS2[2:0] + 1),
t_q = (BRP[9:0] + 1) x t_PCLK

t_q обозначает Time quantum.

t_PCLK = период тактов APB, BRP[9:0], TS1[3:0] и TS2[2:0] определены в регистре CAN_BTR.

Рис. 347. Фреймы CAN.

Примечания:

0 ≤ N ≤ 8
SOF = Start Of Frame (начало фрейма).
ID = Identifier (идентификатор).
RTR = Remote Transmission Request (запрос на передачу от удаленного сетевого узла).
IDE = Identifier Extension Bit (бит расширения идентификатора).
r0 = Reserved Bit (зарезервированный бит).
DLC = Data Length Code (код длины данных).
CRC = Cyclic Redundancy Code (контрольная сумма).
Error flag: флаг ошибки, 6 доминантных бит, если на узле активная ошибка, иначе 6 рецессивных бит.
Suspend transmission: приостановка передачи, применимо только к узлам с пассивной ошибкой.
EOF = End of Frame (конец фрейма).
ACK = Acknowledge bit (бит подтверждения).
Ctrl = Control (управление).

[Прерывания bxCAN]

Для bxCAN выделено 4 вектора прерывания. Каждый источник прерывания может быть независимо разрешен или запрещен программированием регистра разрешения прерываний CAN (CAN Interrupt Enable Register, CAN_IER).

Рис. 348. Флаги событий и генерация прерываний.

• Прерывание передачи (transmit interrupt) может генерироваться от следующих событий:
   – Transmit mailbox 0 стал пустым, установился бит RQCP0 в регистре CAN_TSR.
   – Transmit mailbox 1 стал пустым, установился бит RQCP1 в регистре CAN_TSR.
   – Transmit mailbox 2 стал пустым, установился бит RQCP2 в регистре CAN_TSR.
• Прерывание FIFO0 может генерироваться от следующих событий:
   – Прием нового сообщения, биты FMP0 в регистре CAN_RF0R не равны 00b.
   – Состояние заполненности FIFO0, установлен бит FULL0 в регистре CAN_RF0R.
   – Состояние переполнения FIFO0 (overrun), установлен бит FOVR0 в регистре CAN_RF0R.
• Прерывание FIFO 1 может генерироваться от следующих событий:
   – Прием нового сообщения, биты FMP1 в регистре CAN_RF1R не равны 00b.
   – Состояние заполненности FIFO1, установлен бит FULL1 в регистре CAN_RF1R.
   – Состояние переполнения FIFO1 (overrun), установлен бит FOVR1 в регистре CAN_RF1R.
• Прерывание ошибки и изменения статуса может быть сгенерировано следующими событиями:
   – Произошла ошибка (Error condition), подробную информацию о характере ошибки можно получить в регистре статуса ошибки (CAN Error Status register, CAN_ESR).
   – Пробуждение (Wakeup condition), на сигнале приема CAN Rx обнаружено начало фрейма (SOF).
   – Вход в режим сна (Sleep mode).

[Регистры CAN]

К регистрам периферийного устройства CAN нужно обращаться как к словам (32-битный доступ). Смещение адреса указано относительно базового адреса CAN1_BASE или CAN2_BASE (можно узнать в файле stm32f407xx.h). Для адресного пространства CAN1 зарезервированы адреса 0x40006400 .. 0x400067FF (базовый адрес 0x40006400). Для адресного пространства CAN2 зарезервированы адреса 0x40006800 .. 0x40006BFF (базовый адрес 0x40006800). Регистры со смещениями от 0x200 до 0x31C имеются только у CAN1.

Защита доступа к регистрам. Ошибочный доступ к определенным конфигурационным регистрам может привести к тому, что аппаратура временно нарушит работу всей сети CAN. Таким образом, регистр CAN_BTR может быть модифицирован программой только когда аппаратура CAN находится в режиме инициализации (initialization mode).

Хотя передача некорректных данных не приведет к проблемам на сетевом уровне CAN, это может сильно помешать работе приложения. Передающий mailbox может быть изменен программой только когда mailbox в состоянии empty, см. рис. 340.

Значения фильтра могут быть изменены либо деактивацией банков фильтра, либо установкой бита FINIT. Кроме того, модификация конфигурации фильтра (scale, mode и назначение FIFO) в регистрах CAN_FMxR, CAN_FSxR и CAN_FFAR может быть только когда установлен режим инициализации фильтра (filter initialization mode, FINIT=1) в регистре CAN_FMR.

[Регистры управления и состояния]

[Регистры CAN mailbox]

В этом разделе описываются регистры ящиков сообщений передачи и приема (mailbox, подробнее см. раздел «Хранилище сообщений»).

У ящиков передачи и приема одни и те же регистры, кроме:

• Поля FMI в регистре CAN_RDTxR.
• Приемный mailbox всегда защищен от записи.
• Передающий mailbox можно записывать только когда он пуст, т. е. когда установлен соответствующий бит TME в регистре CAN_TSR.

Есть 3 передающих ящика (TX Mailbox) и 2 приемных ящика (RX Mailbox), как показано на рис. 349. Каждый RX Mailbox позволяет получить доступ к FIFO глубиной в 3 уровня (стек глубиной в 3 сохраненных сообщения), причем доступ в FIFO предоставляется к самому старому принятому сообщению. Каждый mailbox состоит из 4 регистров.

Рис. 349. Ящики приема и передачи.

[Регистры фильтра CAN]

Для отображения / адресов регистров банков фильтра см. таблицу 184.

[Ссылки]

1. RM0090 Reference manual STM32F405/415, STM32F407/417, STM32F427/437 and STM32F429/439 advanced Arm®-based 32-bit MCUs site:st.com.

Недавно мы разбирались с теоретическими аспектами работы протокола CAN – контролем ошибок, организацией арбитража сообщений на шине и т. д. Так вот, сегодня, как и обещал, займемся практической стороной вопроса – реализуем прием и передачу данных по CAN на микроконтроллере STM32.

Для настройки периферии будем использовать STM32CubeMx, в качестве среды разработки я, как обычно, беру IAR. Осталось упомянуть про выбранный контроллер – им сегодня будет STM32F103VE. Но, как вы помните, при работе с STM32 нет никакой проблемы в том, чтобы перейти на другой микроконтроллер или другую IDE 👍

Итак, первый шаг заключается в настройке в CubeMx всей имеющейся периферии. Не буду подробно останавливаться на том, что не касается непосредственно CAN, все можно найти в нашем курсе по этой вот ссылке.

В итоге у нас оказываются задействованы следующие пины контроллера:

Здесь мы уже активировали модуль CAN:

Но пока мы его только включили, необходимо еще выполнить настройку. И самым важным параметром является, конечно, скорость обмена данными. В случае с CAN ситуация не совсем такая, как с другими модулями STM32, для задания скорости мы должны настроить временные характеристики интерфейса, а не просто задать конкретное число:

Давайте разберемся, что это за значения и за что они отвечают. Время передачи одного бита в CAN складывается из:

Все длительности оцениваются через понятие кванта времени, для задания которого мы устанавливаем значение предделителя (в этом проекте он равен 8). Таким образом, мы получаем длительность 1 кванта:

T_{q}  = 222.2medspace нс

Первый сегмент на этой схеме – SYNC_SEG – используется для синхронизации всех узлов сети CAN. Ожидается, что фронт сигнала должен находиться внутри именно этого сегмента.

Второй сегмент — BS1 (Bit segment 1). Стандарт CAN включает в себя два сегмента — PROP_SEG и PHASE_SEG1. Оба этих сегмента в STM32 относятся к сегменту BS1. PROP_SEG нужен для компенсации физических задержек в сети, а PHASE_SEG1 используется для компенсации ошибки смещения фазы сигнала.

Сегмент BS1 определяет положение sample point (точки захвата). В этой точке модуль CAN анализирует уровень сигнала на шине, то есть определяет, принят рецессивный или доминантный бит.

И третий сегмент — BS2 (Bit segment 2). Он представляет из себя сегмент PHASE_SEG2 интерфейса CAN. Его назначение такое же как и у PHASE_SEG1.

Сегмент BS2 определяет положение transmit point (точки передачи), то есть того момента времени, когда модуль CAN выдает на линию определенный бит.

Длительности этих сегментов таковы:

• SYNC_SEG: 1 квант времени
• Bit segment 1 (BS1): 1 — 16 квантов
• Bit segment 2 (BS2): 1 – 8 квантов

Устанавливая длительности различных сегментов, мы получаем время передачи одного бита в квантах. Зная длительность самого кванта, мы легко получаем время передачи бита в секундах. А уже из этого мы рассчитываем скорость передачи данных по шине. Только при настройке CAN нужно пройти в обратном направлении.

Пусть мы хотим задать скорость обмена равной 500 Кбит/с. Тогда время передачи одного бита:

T_{bit}  = frac{1medspace с}{500000medspace} = 2000medspace нс

Длительность одного кванта мы уже задали равной 222,2 нс. Таким образом, время 1-го бита в квантах:

T = frac{T_{bit}}{T_{q}} = 9

Эти 9 квантов нужно распределить между тремя сегментами. SYNC_SEG фиксирован (1 квант), значит остается 8 квантов на сегменты BS1 и BS2. Ставим в этом примере поровну – по 4 кванта и получаем нужную нам скорость обмена данными. И, наконец, можем двигаться дальше — включаем прерывания и генерируем код:

В main() находим функцию инициализации CAN:

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_CAN_Init();

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

Настраивается этот механизм следующим образом:

CAN_FilterTypeDef canFilterConfig;
canFilterConfig.FilterBank = 0;
canFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
canFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
canFilterConfig.FilterIdHigh = 0x0000;
canFilterConfig.FilterIdLow = 0x0000;
canFilterConfig.FilterMaskIdHigh = 0x0000;
canFilterConfig.FilterMaskIdLow = 0x0000;
canFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
canFilterConfig.FilterActivation = ENABLE;
canFilterConfig.SlaveStartFilterBank = 14;
HAL_CAN_ConfigFilter(&hcan, &canFilterConfig);

Собственно, за «пропускаемые» через фильтр ID отвечают эти поля структуры CAN_FilterTypeDef:

canFilterConfig.FilterIdHigh = 0x0000;
canFilterConfig.FilterIdLow = 0x0000;
canFilterConfig.FilterMaskIdHigh = 0x0000;
canFilterConfig.FilterMaskIdLow = 0x0000;

• FilterIdHigh – старшая часть ID
• FilterIdLow– младшая часть ID
• FilterMaskIdHigh– старшая часть маски
• FilterMaskIdLow– младшая часть маски

В данном случае все значения равны 0x0000, это означает, что абсолютно все сообщения будут проходить через фильтр.

Значения FilterIdHigh и FilterIdLow определяют идентификатор, с которым будет сравниваться ID принятого сообщения. А FilterMaskIdHigh и FilterMaskIdLow отвечают за битовую маску, которая, в свою очередь, определяет, какие биты идентификатора будут проверяться, а какие – нет. Единица в маске означает, что бит, который соответствует положению этой единицы, будет проверен. Сейчас на примере все станет окончательно понятно.

Итак, пусть мы хотим принимать только сообщения с ID из диапазона – 0x200 – 0x20F. Тогда настройка будет такой:

canFilterConfig.FilterIdHigh = 0x200 << 5;
canFilterConfig.FilterIdLow = 0x0000;
canFilterConfig.FilterMaskIdHigh = 0x7F0 << 5;
canFilterConfig.FilterMaskIdLow = 0x0000;

Обратите внимание, что для стандартного идентификатора значения  необходимо сместить влево  на 5 бит. Запишем в двоичном виде значения 0x200 – 0x20F, смещенные на 5 битов:

Получается, что мы должны проверять 7 старших битов ID, одинаковые во всех идентификаторах. И, в итоге, получаем значение битов маски равным 0x7F0 << 5 (единицы соответствуют тем битам, которые должны соответствовать заданному в FilterIdHigh значению).

После настройки фильтра мы включаем модуль CAN и разрешаем прерывания по приему данных в FIFO0:

HAL_CAN_Start(&hcan);
HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);

Теперь для приема сообщений CAN мы просто переопределяем соответствующую callback-функцию:

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
  CAN_RxHeaderTypeDef msgHeader;
  uint32_t msgId = 0;
  uint8_t msgData[8];
  
  HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &msgHeader, msgData);
    
  if (msgHeader.IDE == CAN_ID_EXT)
  {
    msgId = msgHeader.ExtId;
  }
  else
  {
    msgId = msgHeader.StdId;
  }
}

В самой функции мы вызываем HAL_CAN_GetRxMessage() для получения принятых данных и, например, проверяем тип идентификатора (расширенный или стандартный). Дальше уже можно использовать принятые данные по назначению. С приемом все понятно, давайте рассмотрим и процесс передачи.

В STM32F10x реализованы 3 так называемых mailbox’а, то есть по сути «почтовых ящика», в которые мы можем складывать наши сообщения. Далее микроконтроллер аппаратно выбирает, какое сообщение отправить в линию. Можно настроить механизм аналогичный FIFO, то есть первое помещенное в mailbox сообщение и отправлено будет первым. А можно настроить периферию на отправку сообщений в соответствии с приоритетом самих сообщений.

Для каждого из mailbox’ов есть соответствующий callback, который вызывается по окончанию передачи:

• void HAL_CAN_TxMailbox0CompleteCallback(CAN_HandleTypeDef *hcan)
• void HAL_CAN_TxMailbox1CompleteCallback(CAN_HandleTypeDef *hcan)
• void HAL_CAN_TxMailbox2CompleteCallback(CAN_HandleTypeDef *hcan)

Отправим тестовое сообщение:

if (HAL_CAN_GetTxMailboxesFreeLevel(&hcan) != 0)
{
  CAN_TxHeaderTypeDef msgHeader;
  uint8_t msgData[8];

  msgHeader.StdId = 0x200;
  msgHeader.DLC = 8;
  msgHeader.TransmitGlobalTime = DISABLE;
  msgHeader.RTR = CAN_RTR_DATA;
  msgHeader.IDE = CAN_ID_STD;
  
  uint32_t mailBoxNum = 0;
  
  for (uint8_t i = 0; i < 8; i++)
  {
    msgData[i] = i;
  }
  
  HAL_CAN_AddTxMessage(&hcan, &msgHeader, msgData, &mailBoxNum);
}

Первым делом вызываем HAL_CAN_GetTxMailboxesFreeLevel(&hcan). Функция возвращает количество свободных mailbox’ов. Если есть хоть один свободный mailbox, то начинаем формировать сообщение на передачу — устанавливаем параметры сообщения, идентификатор и, конечно же, непосредственно данные. Затем вызываем функцию HAL_CAN_AddTxMessage(), которая поместит наше новое сообщение в один из mailbox’ов и активирует соответствующий запрос на передачу.

Обратите внимание, что помимо данных сообщения мы передаем в эту функцию адрес переменной mailBoxNum. Здесь функция сохранит номер почтового ящика, в который отправлено сообщение, этот номер можно использовать для дальнейшей работы, например, в callback’е по окончанию передачи.

Итак, в общем-то, на этом все — CAN настроили, прием и передачу осуществили ) Проект для статьи доступен по ссылке — MT CAN Example.

До скорых встреч и спасибо за внимание 🤝

Здравствуйте. Реализую сеть с помощью CAN шины. Хочу добавить обработку ошибок. Отправитель должен узнать что его пакет не доставлен. Раскрыл даташит, читал и вникал. Появились вопросы. Я буду рассказывать как я понял, а вы меня поправляйте:
Регистр CAN transmit status rikystir (CAN_TSR) имеет следующие биты-флаги:

<Изображение удалено>

TERR0 — флаг ошибки передачи. Если передача неудалась — вылазит этот флаг.
ALST0 — арбитраж проигран. Если арбитраж проигран, то вылезет этот флаг, и контроллер попытается отправить пакет снова (если ретрансмиты включены). Правильно?
TXOK0 — пакет отправлен без ошибок.
RQCP0 — а вот с этим флагом не все понятно. Он выставляется только когда передача успешно завершена? Или когда работа с посылкой закончилась (неважно ошибкой или успехом). Более того на этот флаг есть прерывание:

<Изображение удалено>.

И без знания, что конкретно этот флаг делает, не могу понять в каких случаях вызывается прерывание.
Как вариант я думаю в прерывании, о котором выше сказал проверять все вышеперечисленные флаги и делать выводы.

Но есть отдельные регистры с флагами ошибок и прерывания к ним:

<Изображение удалено>

там есть прерывания от счетчиков ошибок и перехода модуля в пассивный режим и режим отключения от сети. там же есть прерывание, в котором можно посмотреть код последней ошибки. Но как мне кажется код последней ошибки это более разввернутая информация от флагов TERR0 и ALST0. Более того будет не очень удобно работать с двумя прерываниями, в одном из которых информация от доставке, а в другом ошибки.

Ну и вопрос мой следующих — как мониторить ошибки передачи?