Nie takie USB straszne jak je malują, cz.6 - gotowy program

[elvis]

Czas na uzupełnienie programu o brakujące elementy. Na początek deskryptory - używałem ich już poprzednio, ale czas podzielić się kodem.
Plik nagłówkowy usb_desc.h

Kod: Zaznacz cały

#ifndef USB_DESC_H_
#define USB_DESC_H_

#include <stdint.h>

#define  USB_DESC_TYPE_DEVICE                           1
#define  USB_DESC_TYPE_CONFIGURATION                    2
#define  USB_DESC_TYPE_STRING                           3
#define  USB_DESC_TYPE_INTERFACE                        4
#define  USB_DESC_TYPE_ENDPOINT                         5
#define  USB_DESC_TYPE_DEVICE_QUALIFIER                 6
#define  USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION        7
#define  USB_DESC_TYPE_INTERFACE_POWER					8
#define  USB_DESC_TYPE_BOS                              15

#define  HID_REPORT_DESC               					34

#define DEVICE_DESC_SIZE								18
#define CONFIGURATION_DESC_SIZE							34
#define MOUSE_REPORT_DESC_SIZE    						74

extern const uint8_t device_desc[DEVICE_DESC_SIZE];
extern const uint8_t configuration_desc[CONFIGURATION_DESC_SIZE];
extern const uint8_t mouse_report_desc[MOUSE_REPORT_DESC_SIZE];

#endif /* USB_DESC_H_ */

Widzimy w nim trochę deklaracji stałych - USB_DESC_TYPE_ są przepisane z dokumentacji. My używamy raptem 3 deskryptorów:

• device_desc - to deskryptor urządzenia

• configuration_desc - deskryptor konfiguracji, interfejsów i endpointów

• mouse_report_desc - definiuje pakiety używane przez naszą "myszę"

Treść samych deskryptorów to uproszczona wersja z przykładów od ST. Wyrzuciłem z nich napisy, zadeklarowałem również tablice jako stałe - niech sobie siedzą w pamięci Flash zamiast RAM marnować (plik usb_desc.c):

Kod: Zaznacz cały

#include "usb_desc.h"

const uint8_t device_desc[DEVICE_DESC_SIZE] = {
	0x12,							/* bLength */
	USB_DESC_TYPE_DEVICE, 			/* bDescriptorType */
	0x00,              				/* bcdUSB */
	0x02,
	0x00,               			/* bDeviceClass */
	0x00,               			/* bDeviceSubClass */
	0x00,               			/* bDeviceProtocol */
	0x40,           				/* bMaxPacketSize */
	0x83,           				/* idVendor */
	0x04,           				/* idVendor */
	0x40,        					/* idProduct */
	0x57,        					/* idProduct */
	0x00,               			/* bcdDevice rel. 2.00 */
	0x02,
	0x00,           				/* Index of manufacturer  string */
	0x00,       					/* Index of product string */
	0x00,        					/* Index of serial number string */
	0x01  							/* bNumConfigurations */
};

const uint8_t configuration_desc[CONFIGURATION_DESC_SIZE] = {
	0x09, 							/* bLength */
	USB_DESC_TYPE_CONFIGURATION, 	/* bDescriptorType */
	CONFIGURATION_DESC_SIZE,		/* wTotalLength */
	0x00,
	0x01,         					/* bNumInterfaces */
	0x01,         					/* bConfigurationValue */
	0x00,         					/* iConfiguration */
	0xE0,         					/* bmAttributes */
	0x32,         					/* MaxPower 100 mA */

	/* Interface Descriptor */
	0x09,         					/* bLength */
	USB_DESC_TYPE_INTERFACE,		/* bDescriptorType */
	0x00,         					/* bInterfaceNumber */
	0x00,         					/* bAlternateSetting */
	0x01,         					/* bNumEndpoints */
	0x03,         					/* bInterfaceClass: HID */
	0x01,         					/* bInterfaceSubClass: 1=BOOT, 0=no boot */
	0x02,         					/* nInterfaceProtocol: 0=none, 1=keyboard, 2=mouse */
	0,            					/* iInterface: Index of string descriptor */

	/* HID Descriptor */
	0x09,         					/* bLength */
	0x21, 							/* bDescriptorType */
	0x11,         					/* bcdHID: HID Class Spec release number */
	0x01,
	0x00,         					/* bCountryCode */
	0x01,         					/* bNumDescriptors: Number of HID class descriptors to follow*/
	0x22,         					/* bDescriptorType */
	MOUSE_REPORT_DESC_SIZE,			/* wItemLength: Total length of Report descriptor */
	0x00,

	/* Endpoint Descriptor */
	0x07,          					/* bLength */
	USB_DESC_TYPE_ENDPOINT, 		/* bDescriptorType */
	0x81,     						/* bEndpointAddress */
	0x03,          					/* bmAttributes: Interrupt endpoint */
	0x04, 							/* wMaxPacketSize */
	0x00,
	0x0a,          					/* bInterval */
	/* 34 */
};

const uint8_t mouse_report_desc[MOUSE_REPORT_DESC_SIZE] =
{
	0x05,   0x01,
	0x09,   0x02,
	0xA1,   0x01,
	0x09,   0x01,

	0xA1,   0x00,
	0x05,   0x09,
	0x19,   0x01,
	0x29,   0x03,

	0x15,   0x00,
	0x25,   0x01,
	0x95,   0x03,
	0x75,   0x01,

	0x81,   0x02,
	0x95,   0x01,
	0x75,   0x05,
	0x81,   0x01,

	0x05,   0x01,
	0x09,   0x30,
	0x09,   0x31,
	0x09,   0x38,

	0x15,   0x81,
	0x25,   0x7F,
	0x75,   0x08,
	0x95,   0x03,

	0x81,   0x06,
	0xC0,   0x09,
	0x3c,   0x05,
	0xff,   0x09,

	0x01,   0x15,
	0x00,   0x25,
	0x01,   0x75,
	0x01,   0x95,

	0x02,   0xb1,
	0x22,   0x75,
	0x06,   0x95,
	0x01,   0xb1,

	0x01,   0xc0
};

Do dekodowania żądań hosta przyda się również trochę stałych. Ich wartości pochodzą bezpośrednio z dokumentacji protokołu USB. Umieściłem je w pliku usb.h:

Kod: Zaznacz cały

#ifndef USB_H_
#define USB_H_

/* bmRequestType */
#define USB_REQTYPE_DIR_MASK							0x80
#define USB_REQTYPE_TYPE_MASK							0x60
#define USB_REQTYPE_RECIPENT_MASK						0x1f

#define  USB_REQTYPE_TYPE_STANDARD                      0x00U
#define  USB_REQTYPE_TYPE_CLASS                         0x20U
#define  USB_REQTYPE_TYPE_VENDOR                        0x40U

#define  USB_REQTYPE_RECIPIENT_DEVICE                   0x00
#define  USB_REQTYPE_RECIPIENT_INTERFACE                0x01
#define  USB_REQTYPE_RECIPIENT_ENDPOINT                 0x02

/* bRequest */
#define  USB_REQUEST_GET_STATUS                         0
#define  USB_REQUEST_CLEAR_FEATURE                      1
#define  USB_REQUEST_SET_FEATURE                        3
#define  USB_REQUEST_SET_ADDRESS                        5
#define  USB_REQUEST_GET_DESCRIPTOR                     6
#define  USB_REQUEST_SET_DESCRIPTOR                     7
#define  USB_REQUEST_GET_CONFIGURATION                  8
#define  USB_REQUEST_SET_CONFIGURATION                  9
#define  USB_REQUEST_GET_INTERFACE                      10
#define  USB_REQUEST_SET_INTERFACE                      11
#define  USB_REQUEST_SYNCH_FRAME                        12

#endif /* USB_H_ */

Nowa funkcja handle_setup będzie sprawdzała, czy żądanie dotyczy urządzenia, czy interfejsu i przekazywała sterowanie dalej:

Kod: Zaznacz cały

static void handle_setup(const struct setup_request *req)
{
	switch (req->bmRequestType & USB_REQTYPE_RECIPENT_MASK) {
	case USB_REQTYPE_RECIPIENT_DEVICE:
		handle_setup_device(req);
	    break;
	case USB_REQTYPE_RECIPIENT_INTERFACE:
	    handle_setup_interface(req);
	    break;
	default:
		setup_error();
		break;
	}
}

Jeśli dostajemy zapytanie, którego nie potrafimy obsłużyć, odpowiadamy zmianą stanu endpointa na STALL co wykonuje funkcja setup_error:

Kod: Zaznacz cały

static void setup_error(void)
{
	endpoint_set_rx_status(0, USB_EP_RX_STALL);
	endpoint_set_tx_status(0, USB_EP_TX_STALL);
}

Obsługa żądań skierowanych do interfejsu i urządzenia ma postać:

Kod: Zaznacz cały

static void handle_setup_device(const struct setup_request *req)
{
	switch (req->bmRequestType & USB_REQTYPE_TYPE_MASK) {
	case USB_REQTYPE_TYPE_STANDARD:
		switch (req->bRequest) {
		case USB_REQUEST_GET_DESCRIPTOR:
			get_descriptor(req);
			break;
		case USB_REQUEST_SET_ADDRESS:
			set_address(req);
			break;
		case USB_REQUEST_SET_CONFIGURATION:
			set_configuration(req);
			break;
		default:
			setup_error();
			break;
		}
		break;
	default:
		setup_error();
		break;
	}
}

static void handle_setup_interface(const struct setup_request *req)
{
	switch (req->bmRequestType & USB_REQTYPE_TYPE_MASK) {
	case USB_REQTYPE_TYPE_STANDARD:
		switch (req->bRequest) {
		case USB_REQUEST_GET_DESCRIPTOR:
			get_descriptor(req);
			break;
		default:
			setup_error();
			break;
		}
		break;
	default:
		setup_error();
		break;
	}
}

Jak widzimy dekodujemy polecenia:

• GET_DESCRIPTOR - czyli pobranie deskryptora

• SET_ADDRESS - ustawienie nowego adresu urządzenia

• SET_CONFIGURATION - wybór konfiguracji (jest tylko jedna)

Zgodnie ze specyfikacją obsługa USB odbywa się za pomocą automatu stanowego. Definiujemy więc jego stany:

Kod: Zaznacz cały

static enum {
	USB_STATE_DEFAULT,
	USB_STATE_ADDRESSED,
	USB_STATE_CONFIGURED,
}connection_state;

Nazwy też pochodzą ze standardu. DEFAULT jest ustawiany po podłączeniu lub resecie interfejsu. Gdy host przydzieli nam adres, zmieniamy stan na ADDRESSED, a po wyborze konfiguracji na CONFIGURED.
W momencie wyboru konfiguracji otwieramy również nowy endpoint - typu INTERROUT, przez który będziemy wysyłać dane o zachowaniu naszej myszki.

W programie głównym będziemy wysyłać co pewien czas raporty o przesunięciu kursora o 10 pikseli w prawo - tak jak w pierwszym programie, który używał biblioteki od ST:

Kod: Zaznacz cały

struct mouse_report {
	uint8_t buttons;
	int8_t xrel;
	int8_t yrel;
	int8_t wrel;
};

int main(void)
{
	clocks_config();

	usb_init();

	while (1)  {
		struct mouse_report rpt = {0};
		rpt.xrel = 10;
		endpoint_send(1, &rpt, sizeof(rpt), NULL);

		for (volatile uint32_t dly = 0; dly < 2000000; dly++) {}
	}
}

Dodając kilka brakujących callback-ów mamy cały i o dziwo działający program:

Kod: Zaznacz cały

#include <stdio.h>
#include <string.h>
#include "stm32l053xx.h"
#include "endpoint.h"
#include "usb.h"
#include "usb_desc.h"

struct setup_request {
	uint8_t bmRequestType;
	uint8_t bRequest;
	uint16_t wValue;
	uint16_t wIndex;
	uint16_t wLength;
};

static enum {
	USB_STATE_DEFAULT,
	USB_STATE_ADDRESSED,
	USB_STATE_CONFIGURED,
}connection_state;

static uint8_t usb_address;
typedef void (*comm_callback)(uint8_t);

struct {
	const void *tx_buffer;
	int32_t tx_length;
	comm_callback tx_handler;
	void *rx_buffer;
	int32_t rx_length;
	comm_callback rx_handler;
}endpoint[8];

static void usb_reset(void)
{
	endpoint_init(0, 0x040, 0x080);
	endpoint_init(1, 0x0c0, 0x100);

	connection_state = USB_STATE_DEFAULT;
	usb_address = 0;
	USB->DADDR = USB_DADDR_EF;

	endpoint_use_rx_data0(0);
	endpoint_set_type(0, USB_EP_CONTROL);
	endpoint_set_rx_status(0, USB_EP_RX_VALID);
	endpoint_set_rx_status(1, USB_EP_RX_DIS);
	endpoint_set_tx_status(1, USB_EP_TX_DIS);
}

void endpoint_send(uint8_t ep, const void *data, uint16_t length, comm_callback next)
{
	endpoint[ep].tx_handler = next;
	if (length < ENDPOINT_SIZE) {
		endpoint[ep].tx_buffer = NULL;
		endpoint[ep].tx_length = -1;
	} else {
		endpoint[ep].tx_length = length - ENDPOINT_SIZE;
		endpoint[ep].tx_buffer = data + ENDPOINT_SIZE;
		length = ENDPOINT_SIZE;
	}

	endpoint_copy_to(ep, data, length);
	endpoint_set_tx_status(ep, USB_EP_TX_VALID);
}

void endpoint_receive(uint8_t ep, void *data, uint16_t length, comm_callback next)
{
	endpoint[ep].rx_handler = next;
	endpoint[ep].rx_buffer = data;
	endpoint[ep].rx_length = length;

	endpoint_set_rx_status(ep, USB_EP_RX_VALID);
}

static void send_zlp_done(uint8_t ep)
{
	endpoint_set_rx_status(ep, USB_EP_RX_VALID);
}

static void send_zlp(uint8_t ep)
{
	endpoint_send(ep, NULL, 0, send_zlp_done);
}

static void ack_received_handler(uint8_t ep)
{
	endpoint_set_rx_status(0, USB_EP_RX_VALID);
}

static void data_sent_handler(uint8_t ep)
{
	endpoint_receive(ep, NULL, 0, ack_received_handler);
}

static void setup_error(void)
{
	endpoint_set_rx_status(0, USB_EP_RX_STALL);
	endpoint_set_tx_status(0, USB_EP_TX_STALL);
}

static void get_descriptor(const struct setup_request *req)
{
	uint16_t len;
	const uint8_t *pbuf;

	switch (req->wValue >> 8) {
	case USB_DESC_TYPE_DEVICE:
		pbuf = device_desc;
		len = sizeof(device_desc);
		break;
	case USB_DESC_TYPE_CONFIGURATION:
		pbuf = configuration_desc;
		len = sizeof(configuration_desc);
		break;
	case HID_REPORT_DESC:
		pbuf = mouse_report_desc;
		len = sizeof(mouse_report_desc);
		break;
	default:
		setup_error();
		return;
	}

	if (len > req->wLength)
		len = req->wLength;
	endpoint_send(0, pbuf, len, data_sent_handler);
}

static void set_address_done(uint8_t ep)
{
	USB->DADDR = USB_DADDR_EF | usb_address;
	endpoint_set_rx_status(0, USB_EP_RX_VALID);
}

static void set_address(const struct setup_request *req)
{
	uint8_t  addr;

	if ((req->wIndex == 0U) && (req->wLength == 0U) && (req->wValue < 128U)) {
		addr = (uint8_t)(req->wValue) & 0x7FU;

		if (connection_state == USB_STATE_CONFIGURED) {
			setup_error();
		} else {
			endpoint_send(0, NULL, 0, set_address_done);
			usb_address = addr;

			if (addr != 0U)
				connection_state = USB_STATE_ADDRESSED;
			else
				connection_state = USB_STATE_DEFAULT;
		}
	} else {
		setup_error();
	}
}

static void hid_open(void)
{
	endpoint_set_type(1, USB_EP_INTERRUPT);

	endpoint[1].tx_buffer = NULL;
	endpoint[1].tx_length = -1;
	endpoint[1].tx_handler = NULL;
	endpoint_use_tx_data0(1);
	endpoint_set_tx_status(1, USB_EP_TX_NAK);
}

static void hid_close(void)
{
	endpoint_set_tx_status(1, USB_EP_TX_DIS);
}

static void set_configuration(const struct setup_request *req)
{
	static uint8_t cfgidx;

	cfgidx = (uint8_t)(req->wValue);

	if (cfgidx > 1) {
		setup_error();
	} else {
		switch (connection_state) {
		case USB_STATE_ADDRESSED:
			if (cfgidx) {
				connection_state = USB_STATE_CONFIGURED;
				hid_open();
				send_zlp(0);
			} else {
				send_zlp(0);
			}
			break;
		case USB_STATE_CONFIGURED:
			if (cfgidx == 0U) {
				connection_state = USB_STATE_ADDRESSED;
				hid_close();
				send_zlp(0);
			} else {
				send_zlp(0);
			}
			break;
		default:
			setup_error();
			hid_close();
			break;
		}
	}
}

static void handle_setup_device(const struct setup_request *req)
{
	switch (req->bmRequestType & USB_REQTYPE_TYPE_MASK) {
	case USB_REQTYPE_TYPE_STANDARD:
		switch (req->bRequest) {
		case USB_REQUEST_GET_DESCRIPTOR:
			get_descriptor(req);
			break;
		case USB_REQUEST_SET_ADDRESS:
			set_address(req);
			break;
		case USB_REQUEST_SET_CONFIGURATION:
			set_configuration(req);
			break;
		default:
			setup_error();
			break;
		}
		break;
	default:
		setup_error();
		break;
	}
}

static void handle_setup_interface(const struct setup_request *req)
{
	switch (req->bmRequestType & USB_REQTYPE_TYPE_MASK) {
	case USB_REQTYPE_TYPE_STANDARD:
		switch (req->bRequest) {
		case USB_REQUEST_GET_DESCRIPTOR:
			get_descriptor(req);
			break;
		default:
			setup_error();
			break;
		}
		break;
	default:
		setup_error();
		break;
	}
}

static void handle_setup_ep(const struct setup_request *req)
{
	setup_error();
}

static void handle_setup(const struct setup_request *req)
{
	switch (req->bmRequestType & USB_REQTYPE_RECIPENT_MASK) {
	case USB_REQTYPE_RECIPIENT_DEVICE:
		handle_setup_device(req);
	    break;
	case USB_REQTYPE_RECIPIENT_INTERFACE:
	    handle_setup_interface(req);
	    break;
	case USB_REQTYPE_RECIPIENT_ENDPOINT:
		handle_setup_ep(req);
		break;
	default:
		setup_error();
		break;
	}
}

static void use_callback(uint8_t ep, comm_callback *handler)
{
	comm_callback callback = *handler;
	if (callback == NULL)
		return;

	*handler = NULL;
	callback(ep);
}

void USB_IRQHandler(void)
{
	volatile uint32_t status = USB->ISTR;
	struct setup_request req;

	if (status & USB_ISTR_RESET) {
		USB->ISTR = 0;
		usb_reset();
	} else if (status & USB_ISTR_CTR) {
		uint8_t ep = status & 0xf;

		if (status & USB_ISTR_DIR) {
			endpoint_clear_rx(ep);

			if (endpoint_is_setup_req(ep)) {
				// transaction SETUP (RX)
				endpoint_copy_from(0, &req, sizeof(req));
				handle_setup(&req);
			} else {
				// transaction OUT (RX)
				uint16_t length = endpoint_get_rx_length(ep);
				if (length > endpoint[ep].rx_length)
					length = endpoint[ep].rx_length;
				endpoint_copy_from(ep, endpoint[ep].rx_buffer, length);
				endpoint[ep].rx_buffer += length;
				endpoint[ep].rx_length -= length;
				if (length == ENDPOINT_SIZE)
					endpoint_receive(ep, endpoint[ep].rx_buffer, endpoint[ep].rx_length, endpoint[ep].rx_handler);
				else
					use_callback(ep, &endpoint[ep].rx_handler);
			}

		} else {
			// transaction IN (TX)
			endpoint_clear_tx(ep);

			if (endpoint[ep].tx_length >= 0)
				endpoint_send(ep, endpoint[ep].tx_buffer, endpoint[ep].tx_length, endpoint[ep].tx_handler);
			else
				use_callback(ep, &endpoint[ep].tx_handler);
		}
	}
}

static void clocks_config(void)
{
	RCC->APB1ENR |= RCC_APB1ENR_PWREN;
	RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;

	PWR->CR = (PWR->CR & ~PWR_CR_VOS_Msk) | PWR_CR_VOS_0;

	RCC->CR |= RCC_CR_HSEBYP | RCC_CR_HSEON;
	while ((RCC->CR & RCC_CR_HSERDY) == 0) {}

    RCC->CFGR = (RCC->CFGR & ~(RCC_CFGR_PLLSRC_Msk | RCC_CFGR_PLLMUL_Msk | RCC_CFGR_PLLDIV_Msk))
    		| RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMUL12 | RCC_CFGR_PLLDIV3;

    RCC->CR |= RCC_CR_PLLON;
    while ((RCC->CR & RCC_CR_PLLRDY) == 0) {}

    RCC->CFGR = (RCC->CFGR & ~(RCC_CFGR_HPRE_Msk | RCC_CFGR_PPRE1_Msk | RCC_CFGR_PPRE2_Msk))
    		| RCC_CFGR_HPRE_DIV1 | RCC_CFGR_PPRE1_DIV1 | RCC_CFGR_PPRE2_DIV1 | RCC_CFGR_SW_PLL;

	RCC->CRRCR |= RCC_CRRCR_HSI48ON;
	RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
	SYSCFG->CFGR3 |= SYSCFG_CFGR3_ENREF_HSI48;

	while ((RCC->CRRCR & RCC_CRRCR_HSI48RDY) == 0) {}

	RCC->CCIPR |= RCC_CCIPR_HSI48MSEL;

	RCC->IOPENR |= RCC_IOPENR_GPIOAEN | RCC_IOPENR_GPIOBEN | RCC_IOPENR_GPIOCEN | RCC_IOPENR_GPIODEN | RCC_IOPENR_GPIOHEN;
	RCC->APB1ENR |= RCC_APB1ENR_USBEN;
}

static void usb_init(void)
{
	USB->CNTR = 0;
	USB->CNTR = USB_CNTR_FRES;
	USB->ISTR = 0;
	USB->CNTR = USB_CNTR_CTRM | USB_CNTR_RESETM;

	USB->BTABLE = 0;
	USB->BCDR |= USB_BCDR_DPPU;

	usb_reset();

	NVIC_SetPriority(USB_IRQn, 0);
	NVIC_EnableIRQ(USB_IRQn);
}

struct mouse_report {
	uint8_t buttons;
	int8_t xrel;
	int8_t yrel;
	int8_t wrel;
};

int main(void)
{
	clocks_config();

	usb_init();

	while (1)  {
		struct mouse_report rpt = {0};
		rpt.xrel = 10;
		endpoint_send(1, &rpt, sizeof(rpt), NULL);

		for (volatile uint32_t dly = 0; dly < 2000000; dly++) {}
	}
}

Po uruchomieniu kursor ucieka w prawo, a analizator pokazuje że wszystko działa jak powinno:



Gotowy program zamiast 17KB zajmuje teraz niecałe 5KB, ale co najważniejsze pozwala lepiej zrozumieć jaka magia była ukryta w bibliotece.
Zanim zaimplementowałem HID testowałem też CDC, więc zmieniając deskryptor oraz dodają dwa nowe endpointy moglibyśmy mieć w naszym programie działając port szergowy... ale ja już nie mam siły tego opisywać

[l3n1n]

...Zanim zaimplementowałem HID testowałem też CDC, więc zmieniając deskryptor oraz dodają dwa nowe endpointy moglibyśmy mieć w naszym programie działając port szergowy... ale ja już nie mam siły tego opisywać

A szkoda bo myślę, że znowu by było ciekawie.

[Zealota]

Gotowy program zamiast 17KB zajmuje teraz niecałe 5KB, ale co najważniejsze pozwala lepiej zrozumieć jaka magia była ukryta w bibliotece.
Zanim zaimplementowałem HID testowałem też CDC, więc zmieniając deskryptor oraz dodają dwa nowe endpointy moglibyśmy mieć w naszym programie działając port szergowy... ale ja już nie mam siły tego opisywać

No cóż Elvis po raz kolejny świetna robota. Dziękuję Ci za podzielenie się tą wiedza.
Dla mnie USB ma w sobie jakąś magię i tajemnicę, która staram się posiąść, ale idzie bardzo topornie
Niemniej jednak brnę dalej.

Z mojej perspektywy polecam książkę "USB dla niewtajemniczonych w przykładach na mikrokontrolery STM32".
Od strony opisu standardu USB oceniam ją dość wysoko, bo pomimo trudnego tematu, kolejne czytania coraz bardziej odsłaniają tę "tajemnicę".
Wydaje się, że od opisu standardu USB owa książka jest co najmniej poprawna oraz kod do niej dostarczony wydaje się być pisany z zachowaniem zasad dobrego programowania. Książka ma tez jedną zasadniczą wadę - kod oparty jest na przestarzałym bibliotekach SPL, co obecnie bardzo utrudnia jej praktyczne wykorzystanie - na pewno mnie, a dla miłośników CubeMX może być całkowicie niestrawne.

Na szczęście jest internet i od pewnego czasu rozpracowuję tę oto bibliotekę:
https://github.com/dmitrystu/libusb_stm32

Polecam zapoznać się. Jest pisana w "bare metal" zatem nie jest wymagająca pod kątem zasobów.
Działa na sporej liczbie mikrokontrolerów STM32 i kod "wydaje się" bardzo przejrzysty

Standardowo kod np. dla urządzenia combo "CDC + mouse" zajmuje 4800 bajtów flash i 1088 bajtów ram (-Os), z czego bufor PMA to 1024.
Mnie z powodzeniem udało się uruchomić CDC+mouse zarówno z dostarczonego pliku makefile jak i po imporcie do Eclipse.
Odpaliłem na STM32F103 oraz F407, w zanadrzu czekają jeszcze F303, F070 oraz F042.
Po własnej modyfikacji deskryptorów z powodzeniem uruchomiłem CDC+keyboard - przydatny okazał się tutorial dla AVR:
https://eleccelerator.com/tutorial-abou ... scriptors/

Jeszcze z mojej perspektywy istotne jest to, że można użyć tej biblioteki do tanich i słabo wyposażonych uK takich jak F070 czy F042 co powoduje, że mamy możliwość budowy bardzo tanich urządzeń ze sprzętową obsługą USB - dla przypomnienia taki F070 w detalu kosztuje ok 7 zł. Niestety w takiej aplikacji na nic się zda CubeMX - dla tych procków nie da się wygenerować biblioteki USB - to był podstawowy bodziec do poszukiwania czegoś innego.

Twój wpis ewidentnie przybliża mnie do lepszego zrozumienia tej "magii"

[Zealota]

Jeszcze z mojej perspektywy istotne jest to, że można użyć tej biblioteki do tanich i słabo wyposażonych uK takich jak F070 czy F042 co powoduje, że mamy możliwość budowy bardzo tanich urządzeń ze sprzętową obsługą USB - dla przypomnienia taki F070 w detalu kosztuje ok 7 zł. Niestety w takiej aplikacji na nic się zda CubeMX - dla tych procków nie da się wygenerować biblioteki USB - to był podstawowy bodziec do poszukiwania czegoś innego.

Tu niestety grubo się pomyliłem. Do procków w obudowie TSSOP można wygenerować USB Hal, ale trzeba zacząć od przemapowania pinów PA11 oraz PA12 w CubeMX, wtedy dopiero opcje włączenia USB zostaną uaktywnione. Co ciekawe bez HALa takie mapowanie nie jest potrzebne, piny po resecie są już gotowe do działania. Zresztą w wygenerowanym projekcie nie ma wpisów związanych z remapowaniem, ale to już opowieść na inną okazję.

[Zealota]

Mam jeden problem ze zrozumieniem działania.
Zmieniłem deskryptor do pracy jako klawiatura. Używam funkcji endpoint_send do wysyłania, przygotowałem raport 8 bajtów do ustawiania kodów klawiszy, zgodnie z ogólną specyfikacją.
Żeby przesłać kod klawisza odpowiednio wyedytowałem plik raportu zgodnie z tablicą kodów hid. Wysyłam raport co sygnalizuje wciśnięcie klawisza, następnie pusty raport oznaczający zwolnienie klawisza. Przygotowałem kod tak by można wysyłać sekwencję znaków (napis) - coś ala terminal USB. Wszystko działa poprawnie jeśli zrobię obie sekwencje w odpowiednim czasie, tzn ok 10 ms. Robię to oczywiście nieblokująco za pomocą timera programowego (wywołanie funkcji usb_hid_buffer_send() co 1 ms) , niemniej jednak zastanawiam się jak można wykryć, że host dostał dane i mogę już wysyłać następne. Najlepiej gdyby było to za pomocą zdarzeń.

Nie wiem tylko, które flagi, gdzie i w którym momencie sprawdzać. Czy można coś poradzić z moim problemem?
Wiem też, że jest tam callback void (*comm_callback)(uint8_t), który zostanie wywołaniu po ..? No właśnie po czym? W którym momencie?? Próbowałem go używać, ale ewidentnie wywoływał się za szybko...

Zakładam również, że skoro bufor w bibliotece ma 64 bajty, a ja przygotowałem raport 8 bajtów, to całość "wyjdzie" w bez konieczności podziału na bloki danych o długości 64 bajtów.

Kod wygląda mniej więcej tak:

Kod: Zaznacz cały

typedef struct  {
	uint8_t modifier;
	uint8_t reserved;
	uint8_t keycode[6];
} keyboard_report_t;
typedef struct {
	uint8_t keyCode;
	uint8_t modifier;
} T_HID_BUFFER;

static keyboard_report_t hid_keyb_report;
keyboard_report_t * usb_reportPTR_return(void) {return &hid_keyb_report;}

static volatile int8_t usbHidStatus = _usb_hid_idle;

static T_HID_BUFFER HidBuffer[64];	// Bufor na napis 


static inline void usb_hid_buffer_wait_until_send(void) {
	while (usbHidStatus != _usb_hid_idle) {}
}

void usb_hid_buffer_fill( char *bufor ) {
	usb_hid_buffer_wait_until_send();

	T_HID_BUFFER * bufferPTR = HidBuffer;
	while ( *bufor ) {
		translate_asciiChar_to_hid( *bufor, bufferPTR++ );
		bufor++;
	}
	bufferPTR->keyCode  = 0;	// Last character "0"
	bufferPTR->modifier = 0;	// Last modifier "0"
}
/***********************************************************************************************/

static inline void usb_clear_report(void) {
	hid_keyb_report.keycode[0] = 0;
	hid_keyb_report.modifier   = 0;
}
static inline void usb_set_report( T_HID_BUFFER *buffer ) {
	hid_keyb_report.keycode[0]  = buffer->keyCode;
	hid_keyb_report.modifier 	= buffer->modifier;
}
void usb_hid_buffer_send(void) {
	static T_HID_BUFFER * buff = HidBuffer;
	if ( HidBuffer->keyCode == 0 || softTimer5 > 0)
		return;

	switch( usbHidStatus ) {
		case _usb_hid_send_start:
			buff = HidBuffer;
			usbHidStatus = _usb_hid_key_press;
			break;
		case _usb_hid_key_press:
			if ( buff->keyCode != 0 ) {
				usb_set_report( buff++ );		// Przekazujemy kod klawisza
				usbHidStatus = _usb_hid_key_release;
				softTimer5 = 10;
				endpoint_send( 1, usb_reportPTR_return(), sizeof(*usb_reportPTR_return()), NULL );
			}
			else {
				usbHidStatus = _usb_hid_idle;
			}
			break;
		case _usb_hid_key_release:
			usb_clear_report();
			usbHidStatus = _usb_hid_key_press;
			softTimer5 = 10;
			endpoint_send( 1, usb_reportPTR_return(), sizeof(*usb_reportPTR_return()), NULL );
			break;

		default:break;
	}
}


void usb_hid_buffer_send_start(void) {
	usbHidStatus = _usb_hid_send_start;
}

[elvis]

Funkcja endpoint_send jako ostatni parametr pozwala podać callback, który zostanie wywołany zaraz po zakończeniu wysyłania danych.Można wtedy uruchomić timer, który za 10ms wyśle kolejną paczkę.

[Zealota]

Funkcja endpoint_send jako ostatni parametr pozwala podać callback, który zostanie wywołany zaraz po zakończeniu wysyłania danych.Można wtedy uruchomić timer, który za 10ms wyśle kolejną paczkę.

Tak wstępnie założyłem, zrobiłem próby, ale poległem. Uznałem wtedy, że callback jest uruchamiany nie wtedy gdy mamy potwierdzenie, że host odebrał i czeka na następne dane, ale jeszcze w momencie, że jakieś dane jeszcze "idą po magistrali" a jedynie endpoint się oczyścił. Zatem wyciągnąłem złe wnioski. Podejde do tematu jeszcze raz, może to uproście tę moją skromną maszynę stanów z ustawianiem i zerowaniem raportu klawiatury.

Kolejna sprawa, mam podgląd w Saleae, że ramki idą co 1 ms (to prawdopodobnie SOF bo zlicza kolejne ramki), a co ok 8 ms mam dodatkową ramkę z adresem urządzenia oraz numerem endpointa (01). Czyli co ok 8 ms jest powtarzana (utrzymywana) transmisja z hostem - tak sobie to nazywam , zgadza się?
Z tego co wyczytałem i zrozumiałem to czas ten można "regulować" parametrami, tylko gdzie i jak? Od 1 ms do kilkudziesięciu ms.
Z drugiej strony jeśli nawet tak jest to po co to regulować dla klawiatury...

Jeszcze ostatnie pytanie. Jak skorzystać z funkcji endpoint_receive(). Próbowałem podejść do zadania analogicznie jak z funkcją endpoint_send(), ale podejrzewam, że mocno błądzę.
Chciałbym odbierać z hosta informację o zapalonych ledach, capslock itd.
Wstępnie skonfigurowałem raport o długości 1 bajta i robiłem banalny test:

Kod: Zaznacz cały

static uint8_t reportout = 0;

void get_data( uint8_t report ) {
	sw_led_start_blink( 2, 100); // Tu cokolwiek byleby złapać breakpointa
}
void usb_hid_buffer_receive(void) {
	 endpoint_receive( 0, &reportout, sizeof(reportout), get_data );
}

Funkcję usb_hid_buffer_receive() wywołuję co jakiś czas, ale nic nie dostaję. Ustawiam breakpointa ale nie wchodzi do obsługi, robiłem też logowanie w Saleae, na pinie, ale ewidentnie nie wchodzi do callback'a. Zakładam, że test który przeprowadzam jest po prostu niepoprawny, ale niestety brakuje mi pomysłów jak to obsłużyć.

[elvis]

Tak wstępnie założyłem, zrobiłem próby, ale poległem. Uznałem wtedy, że callback jest uruchamiany nie wtedy gdy mamy potwierdzenie, że host odebrał i czeka na następne dane, ale jeszcze w momencie, że jakieś dane jeszcze "idą po magistrali" a jedynie endpoint się oczyścił. Zatem wyciągnąłem złe wnioski. Podejde do tematu jeszcze raz, może to uproście tę moją skromną maszynę stanów z ustawianiem i zerowaniem raportu klawiatury.

To czy dane "idą po magistrali" nie powinno mieć znaczenia. Wydaje mi się, że powinieneś zacząć od poczytania trochę o USB, w największym skrócie: USB (<3.0) prawie zawsze przesyła dane tylko na żądanie hosta. To trochę jak z i2c, urządzenie nie może wysłać danych o np. przyciśnięciu przycisku, czy ruchu myszką, musi czekać aż host zapyta.
Więc callback jest wywoływany, gdy poprzednie dane zostały wstawione do buforów nadawczych, można przygotowywać nowe - ale one nie będą wysłane natychmiast.

Kolejna sprawa, mam podgląd w Saleae, że ramki idą co 1 ms (to prawdopodobnie SOF bo zlicza kolejne ramki), a co ok 8 ms mam dodatkową ramkę z adresem urządzenia oraz numerem endpointa (01). Czyli co ok 8 ms jest powtarzana (utrzymywana) transmisja z hostem - tak sobie to nazywam , zgadza się?
Z tego co wyczytałem i zrozumiałem to czas ten można "regulować" parametrami, tylko gdzie i jak? Od 1 ms do kilkudziesięciu ms.
Z drugiej strony jeśli nawet tak jest to po co to regulować dla klawiatury...

Jeszcze raz - poczytaj trochę o USB zamiast zgadywać. To nieco bardziej skomplikowany protokół niż się wydaje. Co 1ms jest SOF, więc pewnie masz rację. Natomiast co 8ms (dziwne powinno być co 10) host odpytuje czy "myszka" ma dla niego jakieś dane. Najczęściej nic nie ma, ale tylko wtedy faktycznie można coś do hosta wysłać. Dane muszą być przygotowane wcześniej, bo host nie czeka - pyta od razu oczekuje danych, albo informacji że jeszcze nic dla niego nie mamy.
Jak często host ma pytać urządzenie ustawiamy w deskryptorze.

Jeszcze ostatnie pytanie. Jak skorzystać z funkcji endpoint_receive(). Próbowałem podejść do zadania analogicznie jak z funkcją endpoint_send(), ale podejrzewam, że mocno błądzę.
Chciałbym odbierać z hosta informację o zapalonych ledach, capslock itd.
Wstępnie skonfigurowałem raport o długości 1 bajta i robiłem banalny test:

Kod: Zaznacz cały

static uint8_t reportout = 0;

void get_data( uint8_t report ) {
	sw_led_start_blink( 2, 100); // Tu cokolwiek byleby złapać breakpointa
}
void usb_hid_buffer_receive(void) {
	 endpoint_receive( 0, &reportout, sizeof(reportout), get_data );
}

Funkcję usb_hid_buffer_receive() wywołuję co jakiś czas, ale nic nie dostaję. Ustawiam breakpointa ale nie wchodzi do obsługi, robiłem też logowanie w Saleae, na pinie, ale ewidentnie nie wchodzi do callback'a. Zakładam, że test który przeprowadzam jest po prostu niepoprawny, ale niestety brakuje mi pomysłów jak to obsłużyć.

Nic nie dostajesz, bo i skąd host miałby wiedzieć na jakie dane czekasz? Nie wiem jak duże zmiany wprowadziłeś względem programu który przygotowałem - w każdym razie zmiana jednego parametru, czyli:

Kod: Zaznacz cały

/* nInterfaceProtocol: 0=none, 1=keyboard, 2=mouse */

to za mało żeby HID działał poprawnie jako klawiatura.
Natomiast pomijając HID i tak nie można nic odebrać bez dodawania nowego endpointa - kod przykładowy miał być prosty, więc jest tylko jeden endpoint do wysyłania danych z "myszki" do hosta. W drugą stronę tym endpointem się nic nie prześle.