Виртуальный COM-порт на STM32 или как управлять контроллером через USB не привлекая внимания санитаров
Написать эту статью меня сподвигли те сложности, которые пришлось пройти в попытке разобраться, как же именно ядро контроллера STM32F103 работает с драйвером USB, который находится на борту. Имеющиеся туториалы (например, вот или вот) по созданию устройств, в том числе и композитных, в основном сфокусированы на особенностях использования библиотек. Я же хочу рассказать, как оно работает на уровне регистров.
Некоторое время назад мне потребовалось создать драйвер для адресных светодиодов. Это довольно большой проект, в котором есть целый ряд интересных аспектов, но в рамках этой статьи достаточно упомянуть, что, поскольку этот драйвер предназначается для людей творческих профессий и увлечений - бутафоров, декораторов или косплееров, которые далеко не всегда умеют в программирование, а тем более микроконтроллеров, да и сам я больше художник, внутрь устройства был помещён целый интерпретатор команд, подобных G-кодам, который читает с флэш-карты различные сценарии, исполняет их и даже сигнализирует об ошибках. Само собой, на различную периферию оставалось не так много места. И в это место нужно было как-то втиснуть в том числе и обработку команд, поступающих через USB, поскольку это удобно для пользователя.
И вот на этом месте оказалось, что места, как в ПЗУ, так и в ОЗУ для стандартных библиотек уже не остаётся: библиотеки часто пишутся так, чтобы отлавливать ошибки. Поэтому там, где достаточно присвоить пару заранее рассчитанных значений строго определённым регистрам возникают структуры из нескольких переменных и функции со множеством условных переходов. И те и другие пожирают довольно много памяти. Поверх этого библиотеки от STM сами по себе достаточно сложны по своей структуре. Переменные попрятаны в макросы, которые в свою очередь завёрнуты в функции, вызываемые через указатели. Так что пришлось во всё это влезать и разбираться.
Процесс работы с инициализированным USB довольно прост. Но вот процесс инициализации - это головоломка не для слабых умов. Чтобы понять, что там происходит, мне пришлось нарисовать довольно объёмную блок-схему, которая больше похожа на карту подземелья в D&D, чем на алгоритм. И прежде чем спуститься в это подземелье, нам понадобится следующее снаряжение.
Регистры
Итак, что нам понадобится для того, чтобы разобраться. Вообще, полезно иметь под рукой Reference Manual (DOC Id 13902, глава 22, страницы с 580 по 609). В этом документе содержатся адреса нужных для работы регистров и описание битов в этих регистрах. А также режимов работы этих битов (это важно). Для удобства программирования, я вынес эти адреса в макросы:
Макросы
//макрос адресации
#define REG(x) (*((volatile unsigned int )(x)))
//базовый адрес регистров драйвера
#define USB_BASE_ADDR 0x40005C00
//адрес начала области памяти драйвера USB
#define USB_PMA_ADDR 0x40006000
//регистры состояния конечных точек
#define EP0R REG(USB_BASE_ADDR)
#define EP1R REG(0x40005C04)
#define EP2R REG(0x40005C08)
#define EP3R REG(0x40005C0C)
#define EP4R REG(0x40005C10)
#define EP5R REG(0x40005C14)
#define EP6R REG(0x40005C18)
#define EP7R REG(0x40005C1C)
#define ENDPOINT(bEpNum) REG(USB_BASE_ADDR + (bEpNum)*4)
#define PMA_BUF(INum) REG(USB_PMA_ADDR + (INum)4)
#define PMA_SBUF(SINum) (((volatile unsigned short int *)(USB_PMA_ADDR + (SINum)*2)))
//остальные регистры
#define CNTR REG(USB_BASE_ADDR + 0x40)
#define ISTR REG(USB_BASE_ADDR + 0x44)
#define DADDR REG(USB_BASE_ADDR + 0x4C)
#define BTABLE REG(USB_BASE_ADDR + 0x50)В этой части мы немного упрощаем себе жизнь, вызывая нужные нам регистры как переменные или работая с ними как с массивом:
CNTR - контролирует, какие из событий должны вызвать прерывание и обратить на себя внимание контроллера. Нам понадобятся 0x8000 (данные приняты) и 0x0400 (запрос на перезагрузку драйвера). Также есть события по переполнению буфера приёма (0x4000), отправке устройства в спящий режим (0x0800) и выхода из него (0x1000) и т.д.
ISTR - собственно, описание прерывания. Старшие биты (с 15 по 8) - соответствуют регистру CNTR. Младшие 4 указывают номер конечной точки, которая требует внимания и бит номер 4 (0x0010) - это направление: 1 означает, что данные принимаются от хоста (обычно компьютера, но сейчас это умеют и смартфоны) в контроллер. 0 - что хост ждёт данных от нас.
DADDR - младшие 7 бит хранят номер, который хост присвоил нашему устройству в текущей сессии. Изначально ноль. Старший бит указывает, что драйвер USB принципиально готов к работе.
BTABLE - смещение адреса описания конечных точек. Дело в том, что для работы нам нужно куда-то помещать данные - как принятые, так и те, которые мы будем отправлять. Местом для этого служит внутренняя память драйвера, Packet Memory (PMA). И для разметки этой памяти служит таблица, размещаемая в той же самой памяти начиная с позиции BTABLE. Эта таблица состоит из следующих полей: Адрес буфера отправки, количество байт, отправляемых на данном шаге, адрес буфера приёма, размер буфера приёма (и его заполненность).
Наконец, PMA_BUF и PMA_SBUF - та самая внутренняя память драйвера, всего 512 байт. PMA_BUF обращается к ней как к массиву DWORD, а PMA_SBUF обращается к ней как к массиву WORD. Адресация в этой области памяти идёт по словам, так что обратиться к отдельному байту всё равно не получится.
Конечные точки. Как видите, я обращаюсь к ним как по отдельности, так и как к элементам массива. В принципе достаточно второго, но поскольку в ряде случаев работа происходит с конкретной конечной точкой, то для наибольшей прозрачности проще сразу её обозначить.
Сами конечные точки - это дополнительный уровень разделения потоков данных, интерфейсы, через которые хост и контроллер будут общаться. Нулевая конечная точка EP0R получает и передаёт данные, необходимые для настройки. Остальные выполняют ту работу, которую мы собственно хотим получить от нашего устройства.
Запуск USB
Прежде чем начать работу, нам необходимо включить драйвер и подключить соответствующие ноги:
SystemInit();
//Это то, что находится в файле system_stm32f10x.c стандартной библиотеки.
#include "stm32f10x.h"
/* Reset the RCC clock configuration to the default reset state(for debug purpose) */
/* Set HSION bit */
RCC->CR |= (uint32_t)0x00000001;
/* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
RCC->CFGR &= (uint32_t)0xF8FF0000;
/* Reset HSEON, CSSON and PLLON bits */
RCC->CR &= (uint32_t)0xFEF6FFFF;
/* Reset HSEBYP bit */
RCC->CR &= (uint32_t)0xFFFBFFFF;
/* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
RCC->CFGR &= (uint32_t)0xFF80FFFF;
/* Disable all interrupts and clear pending bits */
RCC->CIR = 0x009F0000;
/* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
/* Configure the Flash Latency cycles and enable prefetch buffer */
__IO uint32_t StartUpCounter = 0, HSEStatus = 0;
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
/* Enable HSE */
RCC->CR |= ((uint32_t)RCC_CR_HSEON);
// RCC->CR |= ((uint32_t)RCC_CR_HSION);
/* Wait till HSE is ready and if Time out is reached exit */
do {
HSEStatus = RCC->CR & RCC_CR_HSERDY;
// HSEStatus = RCC->CR & RCC_CR_HSIRDY;
StartUpCounter++;
} while(((RCC->CR & RCC_CR_HSERDY) == 0) && (StartUpCounter < HSE_STARTUP_TIMEOUT));
if ((RCC->CR & RCC_CR_HSERDY) != RESET) // if ((RCC->CR & RCC_CR_HSIRDY) != RESET)
{
//HSEStatus = (uint32_t)0x01;
/* Enable Prefetch Buffer */
FLASH->ACR |= FLASH_ACR_PRFTBE;
/* Flash 2 wait state */
FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;
/* HCLK = SYSCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
/* PCLK2 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
/* PCLK1 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
/* PLL configuration: PLLCLK = HSE * 9 = 72 MHz */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);
//PLLMULL9 - for 8MHz
// RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSI_Div2 | RCC_CFGR_PLLMULL9);
//PLLMULL9 - for 8MHz
/* Enable PLL */
RCC->CR |= RCC_CR_PLLON;
/* Wait till PLL is ready */
while((RCC->CR & RCC_CR_PLLRDY) == 0) { } /* Select PLL as system clock source */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;
/* Wait till PLL is used as system clock source */
while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08) { }
}SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET;
/* Vector Table Relocation in Internal FLASH. */
USB_Init()
SystemInit();
//Содержимое SystemInit описано выше.
//Сама функция находится в файле system_stm32f10x.c стандартной библиотеки.
// Enable USB_DISCONNECT GPIO clock
RCC->APB2ENR |= RCC_APB2Periph_GPIOF;
// Использование 11 пина как USB pull-up pin
GPIOF->CRH &= 0xFFFF0FFF;
GPIOF->CRH |= 0x00007000;
//general output, open drain, 50MHz
//Конфигурация тактирования
*(__IO uint32_t *) (0x424200D8) = 0;
//включить тактирование шины USB
RCC->APB1ENR |=RCC_APB1Periph_USB;
//Приоритет прерывания (низший приоритет из возможных 0xf0, высший 0x10)
NVIC->IP[USB_LP_CAN1_RX0_IRQn] = 0xA0;
//pending - будем проверять в цикле
NVIC->ISER[(uint32_t)(USB_LP_CAN1_RX0_IRQn) >> 0x05] = (uint32_t)0x01 << (USB_LP_CAN1_RX0_IRQn & (uint8_t)0x1F);
USB_RESET();После инициализации и включения тактирования остаётся только выполнить разметку PMA и разрешить USB принимать данные. За это отвечает функция USB_RESET():
USB_RESET()
#define EP0RX_OFFSET 0x80
#define EP0TX_OFFSET 0x40
#define EP1TX_OFFSET 0xC0
#define EP2TX_OFFSET 0x100
#define EP3RX_OFFSET 0x110
BTABLE = 0; // Адрес таблицы дискрипторов внутри PMA
//EP 0 - нулевая конечная точка
// ADDR_TX
PMA_BUF(0) = EP0TX_OFFSET;
// COUNT_TX = 0 нужно заполнять перед отправкой данных
PMA_BUF(1) = 0;
// ADDR_RX
PMA_BUF(2) = EP0RX_OFFSET;
// Указываем размер буфера приема 64 байта, BL_size = 1 (32 байта на блок), 2 штуки
PMA_BUF(3) = 0x8400;
EP0R = ((EP0R ^ 0x3020) & 0x3030) | 0x0200;
//EP 1 CDC TX
PMA_BUF(4) = EP1TX_OFFSET;
PMA_BUF(5) = 0;
PMA_BUF(6) = 0;
PMA_BUF(7) = 0;
ENDPOINT(1) = ((ENDPOINT(1) ^ 0x0020) & 0x3030);
//EP 2 CDC interrupt
PMA_BUF(8) = EP2TX_OFFSET;
PMA_BUF(9) = 0;
PMA_BUF(10) = 0;
PMA_BUF(11) = 0;
ENDPOINT(2) = ((ENDPOINT(2) ^ 0x0020) & 0x3030)|0x0600;
//EP 3 CDC RX
PMA_BUF(12) = 0;
PMA_BUF(13) = 0;
PMA_BUF(14) = EP3RX_OFFSET;
PMA_BUF(15) = 0x8400;
ENDPOINT(3) = ((ENDPOINT(3) ^ 0x3000) & 0x3030);
//Данные глобальные переменные нужны для формирования ответов на запросы хоста:
USB_Feature = 0xC0;
USB_Configuration = 0;
USB_Interface = 0;
//Обнуляем прерывание
ISTR = 0;
// Включаем модуль USB, адрес устройства 0
DADDR = 0x80;
// Дополнительно сбрасываем флаги прерываний(событий) USB
ISTR &= ~ISTR_RESET;
Здесь нам потребуются пояснения, связанные с особенностями работы регистров конечных точек. Разные биты в них отвечают не только за разные режимы работы, но и по-разному реагируют на попытки записать в них 0 или 1. Так что присаживайтесь поудобнее.
Старший бит, 0x8000, CTR_RX отвечает за приём и поднимается тогда, когда в область PMA для конечной точки пришли данные от хоста. Поднять его со стороны контроллера нельзя, только сбросить в 0.
Бит 0x4000, DTOG_RX обозначает чётность принятого пакета данных. При записи в него 1 меняет своё значение. В случае работы с COM-портом он нам не понадобится.
Биты 0x2000 и 0x1000 - STAT_RX - состояние приёмника конечной точки. Может принимать значения 0x3000 - готова к приёму, 0x2000 - данные обрабатываются и точка занята, 0x1000 - ошибка и 0x0000 - выключено. Эти биты переключаются так же, как и DTOG_RX. Именно поэтому вместо EP0R = 0x3020 приходится городить EP0R = ((EP0R ^ 0x3020) & 0x3030)
Бит 0x0800, SETUP - указывает на тип принятых данных, т.е. являются ли эти данные специфической командой.
Бит 0x0400 и 0x0200 - EP_TYPE - тип конечной точки: 0x0000 - данные (BULK), 0x0100 - контрольная (CONTROL), 0x0400 - асинхронная (ISO) и 0x0600 - прерывание для хоста (INTERRUPT).
Бит 0x0100, EP_KIND - дополнительный параметр. Для конечных точек типа BULK этот бит включает двойную буферизацию, режим, при котором области PMA для приёма и передачи данных меняются ролями после каждого принятого пакета. Это нужно для ускорения приёма-передачи. Для конечной точки типа CONTROL данный бит включает режим STATUS_OUT. Бывает нужен при завершении ответа, но в нашем случае работает и без него.
Биты с 0x0080 по 0x0010 (CTR_TX, DTOG_TX, STAT_TX) работают так же, как и старшие 4, только отвечают не за приём, а за передачу данных хосту
младшие 4 бита хранят номер конечной точки. Нам потребуется их заполнить когда устройство получит свой номер от хоста.
Как видно, в проекте у нас 4 конечных точки: контрольная нулевая, одна на передачу (первая), одна для прерываний (вторая) и одна на приём (третья). Таблицу разметки мы расположили в начале PMA. В нулевой ячейке таблицы записываем позицию начальной ячейки отправки для контрольной точки. Затем - сколько байт нужно отправить. Затем - начальная ячейка приёма данных. Последняя ячейка содержит информацию о количестве места и количестве принятых данных: старший бит (0x8000) указывает, что блоки имеют размер 32 байта (если 0 - то 2 байта на блок), затем биты с 0x4000 по 0x0400 - количество этих блоков (минус 1). Максимальный общий размер - 512 байт. Оставшиеся 10 бит будут хранить число принятых конечной точкой байт.
И далее по кругу для остальных конечных точек. При разметке важно, чтобы области PMA для разных нужд не пересекались. Иначе мы не сможем понять, что читаем.
Дескрипторы
Следующий важный момент, без которого мы не сможем настроить наше устройство - дескрипторы. Это заранее заготовленные и отформатированные ответы на запросы хоста "что ты такое" и "как ты работаешь".
Дескриптор устройства
const char DeviceDiscriptor[] = {
0x12, // bLength /
0x01, // bDescriptorType /
0x00, 0x02, // bcdUSB = 2.00 /
// класс и протокол перечислены на сайте https://www.usb.org/defined-class-codes
0x02, // bDeviceClass: CDC /
0x00, // bDeviceSubClass /
0x00, // bDeviceProtocol /
0x40, // bMaxPacketSize0 /
//STMicroelectronics СDC
// данные с сайта https://www.the-sz.com/products/usbid/index.php?v=0x04830x83,
0x04, // idVendor = 0x0483 /
0x40, 0x57, // idProduct = 0x7540 /
0x00, 0x02, // bcdDevice = 2.00 / 1,
// Index of string descriptor describing manufacturer /
2, // Index of string descriptor describing product /
3, // Index of string descriptor describing the device's serial number /
0x01 // bNumConfigurations /
};Дескриптор конфигурации
const char ConfigDescriptor[] = {
//Configuration Descriptor
0x09, // bLength: Configuration Descriptor size
0x02, // bDescriptorType: Configuration
67, // wTotalLength:no of returned bytes
0x00, 0x02, // bNumInterfaces: 2 interface
0x01, // bConfigurationValue: Configuration value
0x00, // iConfiguration: Index of string descriptor describing the configuration
0xC0, // bmAttributes: self powered
0x32, // MaxPower 0 mA
//Interface Descriptor
0x09, // bLength: Interface Descriptor size
0x04, // bDescriptorType: Interface
// Interface descriptor type
0x00, // bInterfaceNumber: Number of Interface
0x00, // bAlternateSetting: Alternate setting
0x01, // bNumEndpoints: One endpoints used
0x02, // bInterfaceClass: Communication Interface Class
0x02, // bInterfaceSubClass: Abstract Control Model
0x01, // bInterfaceProtocol: Common AT commands
0x00, // iInterface:
//Header Functional Descriptor
0x05, // bLength: Endpoint Descriptor size
0x24, // bDescriptorType: CS_INTERFACE
0x00, // bDescriptorSubtype: Header Func Desc
0x10, // bcdCDC: spec release number
0x01, //Call Management Functional Descriptor
0x05, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x01, // bDescriptorSubtype: Call Management Func Desc
0x00, // bmCapabilities: D0+D1
0x01, // bDataInterface: 1
//ACM Functional Descriptor
0x04, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x02, // bDescriptorSubtype: Abstract Control Management desc
0x02, // bmCapabilities
//Union Functional Descriptor
0x05, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x06, // bDescriptorSubtype: Union func desc
0x00, // bMasterInterface: Communication class interface
0x01, // bSlaveInterface0: Data Class Interface
//Endpoint 2 Descriptor
0x07, // bLength: Endpoint Descriptor size
0x05, // bDescriptorType: Endpoint
0x82, // bEndpointAddress: (IN2)
0x03, // bmAttributes: Interrupt
8, // wMaxPacketSize:
0x00, 0xFF, // bInterval:
//Data class interface descriptor
0x09, // bLength: Endpoint Descriptor size
0x04, // bDescriptorType:
0x01, // bInterfaceNumber: Number of Interface
0x00, // bAlternateSetting: Alternate setting
0x02, // bNumEndpoints: Two endpoints used
0x0A, // bInterfaceClass: CDC
0x00, // bInterfaceSubClass:
0x00, // bInterfaceProtocol:
0x00, // iInterface:
//Endpoint 3 Descriptor
0x07, // bLength: Endpoint Descriptor size
0x05, // bDescriptorType: Endpoint
0x03, // bEndpointAddress: (OUT3)
0x02, // bmAttributes: Bulk
64, // wMaxPacketSize: 0x00,
0x00, // bInterval: ignore for Bulk transfer
//Endpoint 1 Descriptor
0x07, // bLength: Endpoint Descriptor size
0x05, // bDescriptorType: Endpoint
0x81, // bEndpointAddress: (IN1)
0x02, // bmAttributes: Bulk
64, // wMaxPacketSize:
0x00, 0x00 // bInterval
};
Дескрипторы обычно довольно подробно описываются во многих туториалах, да и в библиотеках и примерах их найти несложно. Так что эту часть объяснения оставлю коллегам. В частности, USB in a nutshell или USB made simple. Всё-таки моя статья скорее о том, как это добро правильнее передать чтобы оно было воспринято.
А не как тут
При подключении устройство никак не определялось до конца. Вроде COM, но какой-то скомканный. Оказалось, компилятор не смог один из дескрипторов расположить в памяти единым куском. А читаю то я его "от забора и до обеда"! Так что компьютер, вместо того чтобы получить на свой запрос "как ты работаешь", вместо заранее заготовленного ответа "я делаю вот это и вот это" получал ответ "через Ж..." и прекращал дальнейшее общение с устройством. Пришлось этот дескриптор разбить на несколько частей по 16 байт и слать их одну за другой. Заработало.
Потом оказалось, что этот дескриптор я переобъявлял в другом файле, и от костыля удалось избавиться. Теперь каждый раз перепроверяю свои дефайны.
Осталось определить несколько глобальных переменных и функций чтения-записи PMA
Собственно, переменные
typedef enum _CONTROL_STATE{
WAIT_SETUP, SETTING_UP, IN_DATA, OUT_DATA, LAST_IN_DATA, LAST_OUT_DATA, WAIT_STATUS_IN, WAIT_STATUS_OUT, STALLED, PAUSE
} CONTROL_STATE;
//массивы и переменные, через которые мы будем работать
unsigned char USB_Buff1[64];
unsigned char USB_COM_TX_Buff1[64];
uint16_t USB_RX_Start_pointer=0;
uint16_t USB_Recieved_bytes=0;
uint16_t USB_Bytes_to_send_left = 0;
//Эта переменная нужна нам для общения с внешним миром
uint8_t USB_Function_flags=0;
//1 - запрос оправки данных на хост(IN)
//2 - запрос получения данных от хоста (OUT)
//4 - есть, что обработать
//8 - Данные от хоста в EP3 обработаны
//переменные для хранения команд, полученных контрольной точкой
uint16_t USB_Command;
uint16_t USB_wValue;
uint16_t USB_wLength;
//Стадия процесса обработки команды от хоста
CONTROL_STATE USB_state_flag = WAIT_SETUP;
//параметры контрольной конечной точки и конфигурация устройства
uint8_t USB_DADDR = 0;
uint8_t USB_Feature;
uint8_t USB_Configuration;
uint8_t USB_Interface;
uint8_t EPindex;
uint16_t BKIstr=0;
uint16_t SaveTState;
Чтение и запись массивов данных в PMA
//P1 - указатель на первый элемент массива, откуда читаем
//P2 - позиция в массиве PMA, с которой записываем данные
//N - количество байт
//max - размер области PMA размеченный для данной операции
void TO_WRITE_PMA(uint16_t *P1, uint32_t P2, uint16_t N, uint16_t max){
uint8_t i;
N = (N > max)? max : N;
for(i=0; i<N; i+=2){
PMA_SBUF(P2+i) = *P1;
P1++;
}
}
void TO_READ_PMA(uint32_t P2, uint16_t *P1, uint16_t N, uint16_t max){
uint8_t i;
N = (N > max)? max : N;
for(i=0; i<N; i+=2){
*P1 = PMA_SBUF(P2+i);
P1++;
}
}
//генерация текстовых дескрипторов.
//строка Str[] должна оканчиваться пустым символом
//EP - целевая конечная точка
void USB_Message (char Str[], uint8_t EP){
uint16_t b1 = PMA_BUF(EP * 4);
uint8_t i;
//не более 31 символа, т.к. всего у нас 64 байта,
//из которых 2 - это заголовок
//(младший байт - количество, старший - тип дескриптора),
//а остальные - текст в юникоде
for (i = 0; (Str[i] && i < 31); i++) {
b1 += 2;
PMA_SBUF(b1) = Str[i];
}
i =i * 2 + 2 b1 = PMA_BUF(EP * 4);
PMA_SBUF(b1) = i | 0x0300;
//N bytes, 3 - string descriptor
PMA_BUF(EP * 4+1) = i;
}Наконец, входим в подземелье
Во-первых, прерывание. Тут всё просто: определяем причину и выбираем обработчик. Причин у нас две - данные приняты и перезагрузить драйвер (см регистр CNTR выше)
Прерывание
void USB_LP_CAN1_RX0_IRQHandler(){
BKIstr = ISTR;
if(BKIstr & ISTR_CTR){
CTR_LP_CTRX();
}
if(BKIstr & ISTR_RESET){
USB_RESET();
}
}Мы уже знакомы с USB_RESET(), так что не будем туда заглядывать. Настоящее приключение ждёт нас в CTR_LP_CTRX().
Код CTR_LP_CTRX()
#define ISTR_CTR 0x8000
#define ISTR_EP_ID 0x000F
#define EP_CTR_TX 0x0080
#define EP_CTR_RX 0x8000
#define USB_EP0_MAX_PACKET_SIZE 0x0040
void CTR_LP_CTRX() {
uint16_t TempEP;
uint8_t Related_Endpoint, Reserved;
uint16_t USB_wIndex;
while (((BKIstr = ISTR) & ISTR_CTR)) {
// extract highest priority endpoint number
EPindex = (uint8_t)(BKIstr & ISTR_EP_ID);
if (EPindex == 1 && (EP1R & EP_CTR_TX)){ //CDC Transmit
EP1R &= 0x8F0F;
USB_Function_flags |= 1;
} else if (EPindex == 3 && (EP3R & EP_CTR_RX)){ //CDC Receive
USB_Function_flags &= 0xEF;
USB_RX_Start_pointer = 0;
//you can save up current time
//in case you have a limited timeframe for processing this data
EP3R = (EP3R ^ 0x2000) & 0x3F8F;
USB_Recieved_bytes = (PMA_BUF(15)&0x3FF);
TO_READ_PMA(EP3RX_OFFSET, USB_Buff1, 64,64);
USB_Function_flags |= 2;
// Decode and service non control endpoints interrupt
// process related endpoint register
} else if(EPindex == 0){
// Decode and service control endpoint interrupt
// calling related service routine
// (Setup0_Process, In0_Process, Out0_Process)
// save RX & TX status
// and set both to NAK
SaveTState = EP0R & 0x3030;
EP0R = (EP0R^0x2020)&0xBFBF;
// DIR bit = origin of the interrupt
if (BKIstr & ISTR_DIR) {
// DIR = 1 */
// DIR = 1 & CTR_RX => SETUP or OUT int
// DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending
EP0R &=0x0F8F;// SETUP bit kept frozen while CTR_RX = 1
USB_state_flag = STALLED;
if (EP0R & EP_SETUP) {
USB_Command = PMA_SBUF(EP0RX_OFFSET);
USB_wValue = PMA_SBUF(EP0RX_OFFSET+2);
USB_wIndex = PMA_SBUF(EP0RX_OFFSET+4);
USB_wLength = PMA_SBUF(EP0RX_OFFSET+6);
if (USB_wLength == 0)
{
// Setup with no data stage
USB_state_flag = WAIT_STATUS_IN;// After no data stage SETUP
PMA_BUF(1) = 0;
if (USB_Command == 0x0900){ // SET_CONFIGURATION
USB_Configuration = USB_wValue;
} else if (USB_Command == 0x0500){//SET ADDRESS
USB_DADDR = USB_wValue | DADDR_EF;
} else if ((USB_Command &0xFDFF) == 0x0100){//SET FEATURE for Device 0300, CLEAR FEATURE for Device 0100
} else if (USB_Command == 0x0B01 && (USB_Configuration) && ((USB_wIndex & 0xFF) <= 1)){//SET INTERFACE
USB_Interface = USB_wIndex;
} else if (USB_Command == 0x0102){
//EndPoint Clear Feature
Related_Endpoint = USB_wIndex & 0x7F;
if ((USB_wValue == 0)//ENDPOINT_STALL)
&& (USB_wIndex > 0x100) && USB_Configuration)
{
//Get Status of endpoint & stall the request if the related_ENdpoint
is Disabled
TempEP = ENDPOINT(Related_Endpoint);
if (USB_wIndex & 0x80) {
// IN endpoint
if ((TempEP&0x0030)==0x0010)
{
ENDPOINT(Related_Endpoint) = (TempEP ^ 0x0030)&0x8FFF;
}
} else {
// OUT endpoint
if ((TempEP&0x3000)==0x1000)
{
if (Related_Endpoint == 0)
{
// After clear the STALL, enable the default endpoint receiver
PMA_BUF(3) = 0x8400;
EP0R = (EP0R ^ 0x3000)&0xBF8F;
}
else
{
ENDPOINT(Related_Endpoint) = (TempEP ^ 0x3000)&0xFF8F;
}
}
}
}
} else if (USB_Command == 0x0302){
// get Status of endpoint & stall the request if the related_ENdpoint is Disabled
Related_Endpoint = USB_wIndex & 0x7F;
if ((USB_wValue==0) && USB_Configuration){
TempEP = ENDPOINT(Related_Endpoint);
if (USB_wIndex & 0x80) {
if(TempEP&0x0030){
ENDPOINT(Related_Endpoint) = (TempEP ^ 0x0010)&0x8FBF;
}
} else {
if(TempEP&0x3000){
ENDPOINT(Related_Endpoint) = (TempEP ^ 0x1000)&0xBF8F;
}
}
}
} else if ((USB_Command & 0xDDFF) == 0x0021){
//SET_COMM_FEATURE 0221
//SET_CONTROL_LINE_STATE 2221
//SET Linecoding 2021
USB_Message("Device connected\r\0",1);
USB_main_COM_react();
} else {
USB_state_flag = STALLED;
}
SaveTState |= 0x0030;
} else {
// Setup with data stage
USB_state_flag = LAST_IN_DATA;
PMA_BUF(1) = USB_wLength;
if (USB_Command == 0x0680){//GET DESCRIPTOR
if (USB_wValue == 0x0100){
TO_WRITE_PMA(DeviceDiscriptor,EP0TX_OFFSET,0x12,USB_EP0_MAX_PACKET_SIZE);
PMA_BUF(1)= 0x12;
} else if (USB_wValue == 0x0200){
TO_WRITE_PMA(ConfigDescriptor,EP0TX_OFFSET,64,USB_EP0_MAX_PACKET_SIZE);
if (USB_wLength>9){
PMA_BUF(1)= USB_EP0_MAX_PACKET_SIZE;
USB_state_flag = IN_DATA;
}
} else if (USB_wValue == 0x0300){
PMA_SBUF(EP0TX_OFFSET) = 0x0304; // 3 - string descriptor, N=4
PMA_SBUF(EP0TX_OFFSET + 2) = 0x0409;//Lang ID - US
PMA_BUF(1)= 4;
} else if (USB_wValue == 0x0301){
USB_Message("VENDOR\0",0);
} else if (USB_wValue == 0x0302){
USB_Message("Device name\0",0);
} else if (USB_wValue == 0x0303){
uint32_t buf1 = *(__IO uint32_t*)(0x1FFFF7F0);//get unique chip ID
for (Reserved = 2; Reserved<24; Reserved+=2){
PMA_SBUF(EP0TX_OFFSET + Reserved)= (buf1 & 0x7) + '0';
buf1 >>= 3;
}
PMA_SBUF(EP0TX_OFFSET)= 0x0318;
PMA_BUF(1)=24;
}// End of GET_DESCRIPTOR
} else if ((USB_Command&0xFFFE) == 0x0080){// GET STATUS for Device, GET STATUS for Interface
Reserved = 0;
if (USB_Command == 0x0080){
if (USB_Feature & 0x20){// is Remote Wakeup enabled?
Reserved |= 2;
}
if (USB_Feature & 0x40){// is Bus-powered?
Reserved |= 1;
}
}
PMA_SBUF(EP0TX_OFFSET) = Reserved;
} else if (USB_Command == 0x0082){// GET STATUS for EndPoint
Related_Endpoint = USB_wIndex & 0x7F;
PMA_SBUF(EP0TX_OFFSET) =0;
TempEP = ENDPOINT(Related_Endpoint);
if (USB_wIndex & 0x80) {
// get Status of endpoint & stall the request if the related_ENdpoint is Disabled
if(TempEP&0x0030 == 0x0010){
PMA_SBUF(EP0TX_OFFSET) =1;// IN Endpoint stalled
}
} else {
if(TempEP&0x3000 == 0x1000){
PMA_SBUF(EP0TX_OFFSET) =1;//OUT Endpoint stalled
}
}
} else if (USB_Command == 0x0880){//GET CONFIGURATION
PMA_SBUF(EP0TX_OFFSET) = USB_Configuration;
} else if ((USB_Command & 0xFE7F) == 0x2021){
//Get (21A1)/set (20A1) Line Coding
PMA_BUF(EP0TX_OFFSET) = 9600;//baudrate
PMA_SBUF(EP0TX_OFFSET+4) = 0;//parity*256+format
PMA_SBUF(EP0TX_OFFSET+6) = 8;//datatype
} else {
USB_state_flag = STALLED;
}
SaveTState = (0x3030);
}
}
} else {
// DIR = 0
// DIR = 0 => IN int
// DIR = 0 implies that (EP_CTR_TX = 1) always
EP0R &=0x8F0F;
if (USB_state_flag == IN_DATA){
//last 3 bytes of Config Descriptor
//no need to use procedure as there is only 2 assignments
PMA_SBUF(EP0TX_OFFSET) = 0x0040;
PMA_SBUF(EP0TX_OFFSET + 2) = 0;
USB_state_flag = LAST_IN_DATA;
PMA_BUF(1)= 3;
SaveTState = (0x3030);
} else if (USB_state_flag == LAST_IN_DATA){
USB_state_flag = WAIT_STATUS_OUT;
SaveTState = (0x3010);
} else {
if (USB_DADDR){//SetDeviceAddress
for (Reserved = 0; Reserved < EP_NUM; Reserved++) {
ENDPOINT(Reserved) = (ENDPOINT(Reserved) & 0x8F80) | Reserved ;
}
DADDR = USB_DADDR; // set device address and enable device function
USB_DADDR = 0;
}
USB_state_flag = STALLED;
}
}
PMA_BUF(3) = 0x8400;
if (USB_state_flag == STALLED) SaveTState = 0x1010;
EP0R = (EP0R^(SaveTState))&0xBFBF;
return;
}
}
}А теперь я расскажу, что тут происходит. И это именно то, ради чего вся эта статья писалась и ради чего вы её сейчас читаете.
Вначале мы попадаем в цикл, задача которого - обработать все отдельные элементы прерывания по ISTR_CTR (он же 0x8000 - приём данных).
Первое, что мы тут делаем, это определяем, какую именно конечную точку обрабатываем и обрабатываем приём или передачу. Номер конечной точки узнаём из прерывания. Это младшие 4 бита регистра ISTR. Приём или передача регулируются 5 битом (0x0010).
Если у нас актуальная конечная точка номер 1, и бит EP_CTR_TX (0x0080) поднят, хост хочет что-то от нас получить. Однако нам это не важно, так что мы просто опускаем бит CTR_TX (EP1R &= 0x8F0F), и, возможно, что-то делаем. Тут важно отметить, что если мы действительно хотим сформировать и отправить ответ, то нам нужно сначала перевести конечную точку в режим NAK, то есть осуществить операцию EP1R = (EP1R ^ 0x0020) & 0x8F3F, затем записать данные в PMA по адресу EP1TX_OFFSET (хранится в PMA_BUF(4)), затем записать в PMA_BUF(5) количество этих байт, и, наконец, перевести конечную точку в режим "готово" командой EP1R = (EP1R ^ 0x0030) & 0x8FBF
Однако мы вызываем этот процесс из других частей программы, то есть когда именно у нас есть, что отправить. Для этого служит следующая процедура (данные для отправки записаны ранее в рабочий массив USB_COM_TX_Buff1, а их количество хранится в переменной USB_Bytes_to_send_left)
Чтобы отправить данные хосту
Поместить данные (пакет не больше чем USB_EP1_MAX_PACKET_SIZE_TX) в рабочий буфер USB_COM_TX_Buff1,
записать в переменную USB_Bytes_to_send_left количество отправляемых байт в текущем пакете
Вызвать процедуру
#define USB_EP1_MAX_PACKET_SIZE_TX 0x40
//фактическая отправка данных хосту
//данные и их количество записаны в USB_COM_TX_Buff1
//и в USB_Bytes_to_send_left соответственно.
void USB_main_COM_react(){
if (USB_Bytes_to_send_left){
//send pack back to the Host
USB_Function_flags &= 0xFE;
TO_WRITE_PMA(USB_COM_TX_Buff1 ,EP1TX_OFFSET, 64, USB_EP1_MAX_PACKET_SIZE_TX);
PMA_BUF(5) = USB_Bytes_to_send_left;
EP1R = (EP1R^0x0030)&0x8FBF;
USB_Bytes_to_send_left = 0;
uint32_t i = 5000;
while (((EP1R & 0x80) == 0) && (i)) {i--;}
}
}Теперь перейдём к обработчику конечной точки номер 3. Она служит для приёма данных. Итак, актуальная конечная точка номер 3 и её бит EP_CTR_RX (0x8000) поднят. Мы опускаем этот бит и одновременно переводим конечную точку в режим ожидания: EP3R = (EP3R ^ 0x2000) & 0x3F8F. Также можно помахать флагами для внешних частей общей программы, но главное, что нас сейчас интересует - это количество принятых байт. Эта информация находится в младших 10 битах ячейки (PMA_BUF(15)&0x3FF). Далее мы перекладываем данные из PMA в рабочий массив и их как-то обрабатываем.
Но это не всё. Когда мы закончим обработку этих данных, нам необходимо перевести конечную точку в состояние "готова к приёму". Это нужно сделать обязательно, иначе, по прошествии некоторого времени хост решит, что наше устройство зависло. Делается это очень просто: EP3R = (EP3R^0x3000)&0xBF8F. Также можно сбросить количество принятых байт в ноль, как это делалось в процедуре USB_RESET: PMA_BUF(15) = 0x8400.
Обработка полученных данных
Данные лежат в массиве USB_Buff1
их количество записано в переменной USB_Recieved_bytes
после обработки выполнить этот код:
PMA_BUF(15) = 0x8400;
EP3R = (EP3R^0x3000)&0xBF8F;Наконец, самое сложное
Контрольная конечная точка, номер 0.
Помимо простых запросов IN и OUT (EP_CTR_RX и EP_CTR_TX соответственно), есть ещё запрос SETUP (бит 0x0800 в регистре конечной точки EP0R). Принципиально у нас два возможных сценария развития событий - когда команда предполагает ответ и когда не предполагает. Разберём их на примере команды запроса дескриптора конфигурации (как наиболее сложный случай), и на примере назначения адреса устройства.
Танец с бубном номер 1. Отправка дескриптора.
Шаг 1. Из прерывания мы вошли в процедуру и в цикл внутри этой процедуры. Выяснили, что у нас 0 конечная точка. На всякий случай сохраняем состояние приёма и передачи (SaveTState = EP0R & 0x3030), а затем переводим нулевую конечную точку в состояние NAK (обработка данных) и по каналу приёма, и по каналу передачи. Так у нас будет время сформировать ответ хосту.
На этом этапе направление передачи (ISTR_DIR) должно быть OUT (бит поднят), Бит EP_SETUP поднят. Бит EP_CTR_RX тоже поднят(его опускаем).
Копируем данные из области PMA, размеченной для приёма в рабочие переменные. Это будет команда USB_Command = PMA_SBUF(EP0RX_OFFSET);
параметр USB_wValue = PMA_SBUF(EP0RX_OFFSET+2);
индекс USB_wIndex = PMA_SBUF(EP0RX_OFFSET+4);
и длина требуемого ответа USB_wLength = PMA_SBUF(EP0RX_OFFSET+6);
Структура команды следующая:
верхние 8 бит (0x8000 ... 0x0100) - собственно требуемая операция,
7 бит (0x0080) - направление, если поднят, то хост ждёт от нас ответа
5 бит (0x0020) - указывает на то, что запрос специфичен для данного класса устройств
младшие 4 бита - указывают на то, к какому слою USB запрос относится - к устройству, интерфейсу или конечной точке
Теперь мы определяем, нужно ли отправить ответ. Для этого смотрим на USB_wLength. В нашем примере (отправить дескриптор конфигурации) это не ноль.
Смотрим на команду. Её значение 0x0680 - отправить дескриптор. Смотрим на параметр. Он равен 0x0200 - дескриптор конфигурации.
Записываем начало нашего дескриптора в область PMA, которая размечена для отправки данных хосту от конечной точки 0.
Тут у нас может быть два варианта. Поскольку изначально хост не знает размера этого дескриптора, он запрашивает только первые 9 байт (в которых содержится в том числе и информация об общей длине). Это 6 и 7 байты запроса, мы их храним в переменной USB_wLength. В этом случае мы записываем в ячейку PMA (PMA_BUF(1)), в которой хранится количество байт для отправки, число 9. После чего переходим к шагу 3 (LAST_IN_DATA).
Если же у нас запрос полного дескриптора, то может быть 2 варианта: он меньше чем размер буфера отправки, или больше либо равен ему. Если меньше, то записываем то количество байт, которое есть и также переходим к шагу 3 (LAST_IN_DATA). Если же больше, то записываем в PMA_BUF(1) максимальное количество байт, которые можем отправить одним пакетом, и переходим к шагу 2 (IN_DATA).
Шаг 2. IN_DATA. Открываем нулевую конечную точку для приёма и передачи EP0R = (EP0R^0x3030)&0xBFBF и переходим на следующий виток цикла.
Теперь мы попадаем в цикл со следующими параметрами:
(ISTR_DIR) должно быть IN (бит опущен),
EP_SETUP опущен,
Бит EP_CTR_TX поднят(его опускаем)
Если что-то не так, то переводим нулевую конечную точку в состояние STALL (EP0R = (EP0R^0x1010)&0xBFBF) и выходим из цикла.
Если всё так как надо, переводим нулевую конечную точку в состояние NAK на приём и передачу, доотправляем оставшиеся байты дескриптора. Тут может оказаться, что их ноль, но это нормально. Записываем это число в PMA_BUF(1).
Опять же, в этом шаге мы можем крутиться до тех пор, пока оставшееся количество байт для дескриптора будет строго меньше чем максимальный размер пакета для отправки. Тогда мы можем перейти не снова в начало шага 2(IN_DATA), а к шагу 3 (LAST_IN_DATA).
Шаг 3. LAST_IN_DATA. Открываем нулевую конечную точку для приёма и передачи EP0R = (EP0R^0x3030)&0xBFBF и переходим на следующий виток цикла.
Мы снова попадаем в цикл со следующими параметрами:
ISTR_DIR должно быть IN (бит опущен),
EP_SETUP опущен,
Бит EP_CTR_TX поднят(его опускаем).
Если что-то не так, то переводим нулевую конечную точку в состояние STALL (EP0R = (EP0R^0x1010)&0xBFBF) и выходим из цикла.
Если всё так как надо, переводим нулевую конечную точку в состояние RX_VALID, TX_STALL (EP0R = (EP0R^0x3010)&0xBFBF). И снова попадаем в цикл, но параметры у нас вот такие:
ISTR_DIR должно быть OUT (бит поднят),
EP_SETUP опущен,
Бит EP_CTR_RX тоже поднят(его опускаем).
Переводим нулевую конечную точку в состояние STALL (EP0R = (EP0R^0x1010)&0xBFBF) и выходим из цикла.
Дескриптор отправлен.
Танец с бубном номер 2. Получение адреса устройства.
Шаг 1 начинается так же.
Из прерывания мы вошли в процедуру и в цикл внутри этой процедуры. Выяснили, что у нас 0 конечная точка. На всякий случай сохраняем состояние приёма и передачи (SaveTState = EP0R & 0x3030), а затем переводим нулевую конечную точку в состояние NAK (обработка данных) и по каналу приёма, и по каналу передачи. Так у нас будет время сформировать ответ хосту.
На этом этапе направление передачи (ISTR_DIR) должно быть OUT (бит поднят), Бит EP_SETUP поднят. Бит EP_CTR_RX тоже поднят(его опускаем).
Копируем данные из области PMA, размеченной для приёма в рабочие переменные. Это будет команда USB_Command = PMA_SBUF(EP0RX_OFFSET);
параметр USB_wValue = PMA_SBUF(EP0RX_OFFSET+2);
индекс USB_wIndex = PMA_SBUF(EP0RX_OFFSET+4);
и длина требуемого ответа USB_wLength = PMA_SBUF(EP0RX_OFFSET+6);
Смотрим на USB_wLength. На этот раз она равно нулю. Смотрим на команду. Её значение 0x0500 - назначить адрес. Значение адреса записано в USB_wValue, переписываем её во временную переменную USB_DADDR, заодно поднимая ей старший бит. Можно этого не делать, просто так немного удобнее. Переходим к шагу 2 (WAIT_STATUS_IN).
Шаг 2. WAIT_STATUS_IN. Открываем нулевую конечную точку для приёма и передачи EP0R = (EP0R^0x3030)&0xBFBF и переходим на следующий виток цикла.
Теперь мы попадаем в цикл со следующими параметрами:
(ISTR_DIR) должно быть IN (бит опущен),
EP_SETUP опущен,
Бит EP_CTR_TX поднят(его опускаем)
Тут мы только проверяем, нужно ли нам назначить адрес (для этого мы и записывали в USB_DADDR значение). Если да, то переписываем его в регистр адреса DADDR, и записываем в младшие 4 бита каждой из используемых конечных точек их номер - это будет сигнализировать драйверу, что с ними можно работать.
И наконец переводим нулевую конечную точку в состояние STALL (EP0R = (EP0R^0x1010)&0xBFBF) и выходим из цикла.
Адрес назначен.
И напоследок,
Ещё несколько команд, которые нужно уметь обрабатывать
Таблица
Команда (USB_Command) | Что от нас требуется |
0x0900 | Выбрать активную конфигурацию устройства (сконфигурировать). Номер конфигурации находится в USB_wValue и не должен превышать максимальное для нашего устройства |
0x0500 | Назначить адрес для данного устройства в текущей сессии. Адрес может быть от 1 до 127 (0 означает, что устройство пока без адреса). Именно по этому номеру хост будет обращаться к устройству |
0x0100 | Выключить возможность перевода устройства в спящий режим и обратно через порт (Clear Feature) |
0x0300 | Включить возможность перевода устройства в спящий режим и обратно (SET Feature) |
0x0B01 | Включить определённый интерфейс. Номер интерфейса содержится в младшем байте USB_wIndex, не должно быть больше чем количество интерфейсов у устройства и устройство к этому моменту должно быть сконфигурировано. |
0x0102 | Перевести конечную точку в состояние VALID (0x3000 или 0x0030), при условии, что она находится в состоянии STALL. Номер конечной точки находится в младших 7 битах USB_wIndex, направление - в 8м бите. Устройство должно быть сконфигурировано, конечная точка - активна. |
0x0302 | Перевести активную конечную точку в состояние STALL |
0x0221 | Настроить COM порт В моём коде в этом месте ничего не происходит, но я заметил, что к этому моменту устройство и хост уже достаточно хорошо познакомились, и этот (а так же один из двух следующих) запрос приходит в момент подключения терминала. Таким образом сюда можно поставить, например, приветствие. |
0x2021 | Настроить бодрейт и прочие параметры передачи |
0x2221 | Настроить состояние линии управления портом |
0x0680 | Отправить хосту дескриптор. Какой именно определяется параметром USB_wValue: |
0x0080 | Отправить хосту статус устройства. Если питается от хоста, то поднять бит 0x01, если возможность перевода в спящий режим и обратно включена, поднять бит 0x02. Иначе вернуть 0 |
0x0081 | Статус интерфейса. Возвращаем 0. |
0x0082 | Статус конечной точки. Номер конечной точки находится в младших 7 битах USB_wIndex, направление - в 8м бите. |
0x0880 | Вернуть номер конфигурации. Это той, которую мы назначали командой 0x0900 |
0x2021 | Обозначить бодрейт и прочие параметры передачи. И вернуть результат: |
0x2121 | Передать хосту бодрейт и прочие параметры передачи. Ответ формируется так же, как и в предыдущем случае. |
Надеюсь, что кому-то эта статья будет полезна. По крайней мере, именно такого разбора мне самому не хватало в процессе изучения библиотек и логики работы USB.