STM32 USB НАЧАЛО.

STM32 USB НАЧАЛО.

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

Проблема в том, что за счет того, что обмен идет непрерывно на большой скорости, привычным способом, устанавливая breakpoint, его отлаживать не получиться. Да и сам процесс обмена достаточно сложен и желательно перед глазами иметь картинку для лучшего понимания происходящего.
Оказалось, что китайский salea logic решает эти проблемы, он записывает обмен данными между устройством и компом декодируя при этом посылки.

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

Картинка ниже очень наглядно показывает, как программно реализован usb.
STM32 USB НАЧАЛО.

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

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

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

Для этого надо понимать как происходит общение:
  • Устройство подтягивает к питанию одну из линий передачи данных , таким образом хост узнает о его подключении.
  • Host подает сигнал сброса в шину. Для устройства это значит, что хост собирается с ним общаться и необходимо создать конечную точку.


Давайте оформим это в виде кода.

Инициализируем usb.
void USB_Init(void)
{
	//включаем тактирование порта и альтернативных функций
	RCC -> APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_AFIOEN;
	//настраиваем порты
	GPIOA->CRH &= ~GPIO_CRH_CNF11;
	GPIOA->CRH |= GPIO_CRH_CNF11_1;
	GPIOA->CRH |= GPIO_CRH_MODE11;
	
	GPIOA->CRH &= ~GPIO_CRH_CNF12;
	GPIOA->CRH |= GPIO_CRH_CNF12_1;
	GPIOA->CRH |= GPIO_CRH_MODE12;
	
        //выключаем предделитель usb 
	RCC->CFGR &= ~RCC_CFGR_USBPRE;
        //включаем тактирования usb
	RCC -> APB1ENR |= RCC_APB1ENR_USBEN;
	//выходим из power down
	USB->CNTR &=~ USB_CNTR_PDWN; 
        //небольшая задержка
	uint32_t temp;
	for ( temp=30000; temp != 0; temp--);
	
	//сбрасываем бит, который ресетит usb
	USB->CNTR &=~ USB_CNTR_FRES;
	//разрешаем прерывания по RESET и CTRM(correct transfer interrupt mask)
	USB -> CNTR |= USB_CNTR_RESETM | USB_CNTR_CTRM;
	//очищаем флаги прерывания
	USB -> ISTR = 0;
	//таблица конечных точек начинается с адреса 0x40006000
        USB -> BTABLE = 0;
        //подтягиваем вывод D+ к питанию
	USB_PULL_UP
        //разрешаем прерывание по приему данных
	NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
}

Тут может возникнуть вопрос, что такое таблица конечных точек?
Так как посылки у usb могут быть разной длины и большого размера, разработчики МК не стали делать для получаемых/принимаемых данных отдельный регистр, для каждой конечной точки. Они выделили для этой цели кусок памяти!!! А для того, чтобы МК понимал, где заканчивается одна точка и начинается другая, в начале этой памяти расположена таблица.

То есть если мы хотим отправить данные, используя нулевую точку, мы записываем данные по нужному адресу. Остальное МК сделает за нас.

Описываем прерывание.

void USB_LP_CAN1_RX0_IRQHandler()
{
	uint8_t n;
	if (USB -> ISTR & USB_ISTR_RESET)
        {
		//создаем 0 конечную точку, типа CONTROL
		EP_Init(0, EP_TYPE_CONTROL, 128, 192);
		//создаем 1 конечную точку, типа BULK
		EP_Init(1, EP_TYPE_BULK, 256, 320);
		//обнуляем адрес устройства
		USB -> DADDR = USB_DADDR_EF;
		//присваиваем состояние DEFAULT STATE
		USB_Dev.USB_Status = USB_DEFAULT_STATE;
	}
}


Создаем конечную точку.

void EP_Init(uint8_t number, uint8_t type, uint32_t addr_tx, uint32_t addr_rx)
{
	USB -> EPnR[number] = (type << 9) | (number & USB_EPnR_EA);
	USB -> EPnR[number] ^= USB_EPnR_STAT_RX | USB_EPnR_STAT_TX_1;
	USB_BTABLE -> EP[number].USB_ADDR_TX = addr_tx;
	USB_BTABLE -> EP[number].USB_COUNT_TX = 0;
	USB_BTABLE -> EP[number].USB_ADDR_RX = addr_rx;
	USB_BTABLE -> EP[number].USB_COUNT_RX = 0x8400;	//размер приемного буфера
	endpoints[number].tx_buf = (uint16_t *)(USB_BTABLE_BASE + 2*addr_tx);
	endpoints[number].rx_buf = (uint8_t *)(USB_BTABLE_BASE + 2*addr_rx);
}


Теперь когда конечная точка создана можно обмениваться данными.
  • Host шлет запрос GET_STATUS. Это своеобразное приветствие, чтобы понять, что конечная точка настроена, устройство понимает хост и дальнейшее общение имеет смысл. Он ожидает от устройства статус default state.
  • Host шлет запрос GET_DESCRIPTOR для получения основной информации о устройстве, в том числе максимальном размере пакета для нулевой конечной точки.


Что касается дескриптора устройства, оставлю тут табличку в которой расписано назначение каждого байта.
STM32 USB НАЧАЛО.


Тут начинается самое интересное, для начала расширим код нашего прерывания, для случая когда МК успешно принял данные.

if (USB -> ISTR & USB_ISTR_CTR)
{
		//определяем номер конечной точки, которая вызвала прерывание
		n = USB -> ISTR & USB_ISTR_EP_ID;
		//копируем количество принятых байт
		endpoints[n].rx_cnt = USB_BTABLE -> EP[n].USB_COUNT_RX;
		//копируем содержимое EPnR этой конечной точки
		endpoints[n].status = USB -> EPnR[n];
		//обновляем состояние флажков
		endpoints[n].rx_flag = (endpoints[n].status & USB_EPnR_CTR_RX) ? 1 : 0;
		endpoints[n].setup_flag = (endpoints[n].status & USB_EPnR_SETUP) ? 1 : 0;
		endpoints[n].tx_flag = (endpoints[n].status & USB_EPnR_CTR_TX) ? 1 : 0;
		//очищаем флаги приема и передачи
		endpoints[n].status = CLEAR_CTR_RX_TX(endpoints[n].status);
		USB -> EPnR[n] = endpoints[n].status;
}


Теперь добавим, функции записи и чтения конечных точек.

void EP_Write(uint8_t number, uint8_t *buf, uint16_t size){
	uint8_t i;
	uint32_t timeout = 1000000;
	uint16_t status = USB -> EPnR[number];
	if (size > 64) size = 64;
	uint32_t *pv = (uint32_t*)(endpoints[number].tx_buf);
/*
 * ВНИМАНИЕ КОСТЫЛЬ
 * Из-за ошибки записи в область USB/CAN SRAM с 8-битным доступом
 * пришлось упаковывать массив в 16-бит, сообветственно размер делить
 * на 2, если он был четный, или делить на 2 + 1 если нечетный
 */
	uint16_t temp = (size & 0x0001) ? (size + 1) / 2 : size / 2;
	for(i = 0; i < temp; i++, buf += 2)
  {
		*pv++ = *((uint16_t *)buf);
	}
	//Количество передаваемых байт
	USB_BTABLE -> EP[number].USB_COUNT_TX = size;

	status = KEEP_STAT_RX(status);		//RX в NAK
	status = SET_VALID_TX(status);		//TX в VALID
	status = KEEP_DTOG_TX(status);
	status = KEEP_DTOG_RX(status);
	USB -> EPnR[number] = status;

	endpoints[number].tx_flag = 0;
	while (!endpoints[number].tx_flag){
		if (timeout) timeout--;
		else break;
	}
}



/*
 * Функция чтения массива из буфера конечной точки
 * number - номер конечной точки
 * *buf - адрес массива куда считываем данные
 */
void EP_Read(uint8_t number, uint8_t *buf){
  uint32_t timeout = 100000;
  uint16_t status, i, n;
  uint32_t *pm = (uint32_t *)endpoints[number].rx_buf;
  uint16_t *p = (uint16_t *)buf; 
 
  status = USB -> EPnR[number];
  status = SET_VALID_RX(status);
  status = SET_NAK_TX(status);
  status = KEEP_DTOG_TX(status);
  status = KEEP_DTOG_RX(status);
  USB -> EPnR[number] = status;
  endpoints[number].rx_flag = 0;
  while (!endpoints[number].rx_flag){
      if (timeout) timeout--;
      else break;
  }
  n = (endpoints[number].rx_cnt & 0x01) ? (endpoints[number].rx_cnt + 1) / 2 : endpoints[number].rx_cnt / 2;
      for (i = 0; i < n; i++){
          p[i] = (uint16_t)pm[i];
      }
}


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