Elektronika i Programowanie: [35] STM32F4

W tym poście chciałbym przedstawić projekt układu z tzw Custom HID. Czyli układem komunikującym się poprzez USB z komputerem.

[Źródło: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

Poniżej przedstawię dwa projekty, jeden pozwalający na komunikację z programem STM USB HID Demonstrator v 1.02 oraz drugi działający jako klawiatura z opcją zmiany dźwięku.

Napisanie własnego deskryptora:

Tutaj opiszę w jaki sposób wykonać przykładowy deskryptor. Najpierw opiszę przykładowy deskryptor dla klawiatury. Po tym przejdę do opisania deskryptora customowego dla programu Demonstrator.

Poniżej przedstawiony jest przykładowy deskryptor HID:

__ALIGN_BEGIN static uint8_t USBD_HID_Desc[USB_HID_DESC_SIZ] __ALIGN_END =
{
/* 18 */
0x09, /*bLength: HID Descriptor size*/
HID_DESCRIPTOR_TYPE, /*bDescriptorType: HID*/
0x11, /*bcdHID: HID Class Spec release number*/
0x01,
0x00, /*bCountryCode: Hardware target country*/
0x01, /*bNumDescriptors: Number of HID class descriptors to follow*/
0x22, /*bDescriptorType*/
HID_CUSTOM_REPORT_DESC_SIZE, /*wItemLength: Total length of Report descriptor*/
0x00,
};

W nim zawarte są takie informacje jak np. Rodzaj klas HID, typ deskryptora, wielkość ramki.

Drugi tzw deskryptor urządzenia wygląda następująco:

__ALIGN_BEGIN uint8_t USBD_FS_DeviceDesc[USB_LEN_DEV_DESC] __ALIGN_END =
{
0x12, /*bLength */
USB_DESC_TYPE_DEVICE, /*bDescriptorType*/
#if (USBD_LPM_ENABLED == 1)
0x01, /*bcdUSB */ /* changed to USB version 2.01
in order to support LPM L1 suspend
resume test of USBCV3.0*/
#else
0x00, /* bcdUSB */
#endif
0x02,
0x00, /*bDeviceClass*/
0x00, /*bDeviceSubClass*/
0x00, /*bDeviceProtocol*/
USB_MAX_EP0_SIZE, /*bMaxPacketSize*/
LOBYTE(USBD_VID), /*idVendor*/
HIBYTE(USBD_VID), /*idVendor*/
LOBYTE(USBD_PID_FS), /*idVendor*/
HIBYTE(USBD_PID_FS), /*idVendor*/
0x00, /*bcdDevice rel. 2.00*/
0x02,
USBD_IDX_MFC_STR, /*Index of manufacturer string*/
USBD_IDX_PRODUCT_STR, /*Index of product string*/
USBD_IDX_SERIAL_STR, /*Index of serial number string*/
USBD_MAX_NUM_CONFIGURATION /*bNumConfigurations*/
} ;

W nim zawarte są takie elementy jak wersja standardu USB, numer identyfikacyjny producenta czyli VendorID oraz urządzenia ProductID. Te numery nadawane są przez USB-IF i do aplikacji wprowadzanych na rynek nie należy ich modyfikować. W każdym systemie może spokojnie pracować kilka urządzeń o jednakowych numer VID oraz PID, gdzie każde z tych urządzeń może pełnić różne funkcje. Z tego powodu nie ma w zasadzie potrzeby ich modyfikowania.

Dla klawiatury możliwe jest kliknięcie klawisza specjalnego czyli ctrl, alt itp. oraz 6 klawiszy określających wprowadzony przycisk. Poniżej przedstawię przykładowy deskryptor raportów dla tego urządzenia.

Najpierw deskryptor musi zostać obudowany w informacje o tym że korzystamy z klawiatury:

0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
0x09, 0x06, // Usage (Keyboard)
0xA1, 0x01, // Collection (Application)
0x85, 0x01, // Report ID (1)
/*
Main descriptor part
*/
0x05, 0x07, // Usage Page (Keyboard)
0xC0, // End Collection

Kolejnym krokiem jest definiowanie wielkości raportu oraz ilości danych jakie mają zostać przesłane z raportem:

0x75, 0x01, // Report Size (1)
0x95, 0x08, // Report Count (8)

Jak widać powyżej przesyłany będzie jeden raport wraz z ośmioma bajtami.

Następnie definiowane jest pole informujące o numerach dotyczących klawiszy specjalnych:

0x19, 0xE0, // Usage Minimum (0xE0 224)
0x29, 0xE7, // Usage Maximum (0xE7 231)

Jak widać tutaj wartości minimalne i maksymalne. Nie odnoszą się one do przesyłanych wartości a jedynie do zakresu jaki ma być przyjmowany. Tutaj widać, do dyspozycji klawiszy specjalnych przeznaczony jest jeden bajt danych. Dzięki temu nie ma konieczności przesyłania większej paczki danych.

Klawisze specjalne przyjmują następującą postać:

#define CONTROL_LEFT (1<<0)
#define SHIFT_LEFT (1<<1)
#define ALT_LEFT (1<<2)
#define GUI_LEFT (1<<3)
#define CONTROL_RIGHT (1<<4)
#define SHIFT_RIGHT (1<<5)
#define ALT_RIGHT (1<<6)
#define GUI_RIGHT (1<<7)

Przyciski mogą przyjmować dwa stany wysoki oraz niski:

0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)

Następna linia informuje o tym, że pakiet danych zostanie przesłany do komputera:

0x81, 0x02, // Input (Data,Var,Abs)

Jak już opis klawiszy specjalnych został zrealizowany to zostało przygotowanie klawiszy głównych:

0x95, 0x06, // Report Count (6)
0x75, 0x08, // Report Size (8)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x65, // Logical Maximum (101)
0x05, 0x07, // Usage Page (Keyboard)
0x19, 0x00, // Usage Minimum (Reserver)
0x29, 0x65, // Usage Maximum (Keyboard aplication)
0x81, 0x00, // Input (Data,Array,Abs)

W tym przypadku jak wspomniałem wcześniej do wysłania będzie 6 klawiszy wobec tego cały raport wyniesie 8 bajtów.

Pełny deskryptor dla klawiatury wygląda następująco:

0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
0x09, 0x06, // Usage (Keyboard)
0xA1, 0x01, // Collection (Application)
0x85, 0x01, // Report ID (1)
0x05, 0x07, // Usage Page (Keyboard)
0x75, 0x01, // Report Size (1)
0x95, 0x08, // Report Count (8)
0x19, 0xE0, // Usage Minimum (0xE0 224)
0x29, 0xE7, // Usage Maximum (0xE7 231)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x81, 0x02, // Input (Data,Var,Abs)
0x95, 0x06, // Report Count (6)
0x75, 0x08, // Report Size (8)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x65, // Logical Maximum (101)
0x05, 0x07, // Usage Page (Keyboard)
0x19, 0x00, // Usage Minimum (Reserver)
0x29, 0x65, // Usage Maximum (Keyboard aplication)
0x81, 0x00, // Input (Data,Array,Abs)
0xC0, // End Collection

Przykładowa funkcja przesyłająca dla klawiatury wygląda następująco:

void sendKeyboardData(uint8_t keySpecial, uint8_t key1, uint8_t key2, uint8_t key3, uint8_t key4,
uint8_t key5, uint8_t key6)
{
keyboard_Typedef keyboardReport;
keyboardReport.id = 0x01;
keyboardReport.speciakKey = keySpecial;
keyboardReport.key1 = key1;
keyboardReport.key2 = key2;
keyboardReport.key3 = key3;
keyboardReport.key4 = key4;
keyboardReport.key5 = key5;
keyboardReport.key6 = key6;
USBD_HID_SendReport(&hUsbDeviceFS, (uint8_t*)&keyboardReport, sizeof(keyboard_Typedef));
HAL_Delay(100);
keyboardReport.id = 0x01;
keyboardReport.speciakKey = 0;
keyboardReport.key1 = 0;
keyboardReport.key2 = 0;
keyboardReport.key3 = 0;
keyboardReport.key4 = 0;
keyboardReport.key5 = 0;
keyboardReport.key6 = 0;
USBD_HID_SendReport(&hUsbDeviceFS, (uint8_t*)&keyboardReport, sizeof(keyboard_Typedef));
}

Dokładniejszy opis można znaleźć we wcześniejszym poście (34).

Kolejny opisywany deskryptor dotyczy klawiszy multimedialnych. W tym przypadku należy dołączyć specjalny opis klawiszy wraz z raportem.

Na samym początku informacje dla urządzenia, że będziemy wykorzystywać customową klasę:

0x05, 0x0C, // Usage Page (Consumer)
0x09, 0x01, // Usage (Consumer Control)
0xA1, 0x01, // Collection (Application)
0x85, 0x02, //Report ID (2)
0x05, 0x0C, //Usage Page (Consumer)

Teraz stany przycisków:

0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)

Wielkość raportu:

0x75, 0x01, // Report Size (1)
0x95, 0x08, // Report Count (7)

Przesłanie pojedynczego raportu z siedmioma bitami dla dla klawiszy specjalnych.

Każdy z klawiszy musi zostać odpowiednio zdefiniowany w raporcie:

0x09, 0xE9, // Usage (Volume Increment),
0x09, 0xEA, // Usage (Volume Decrement),
0x09, 0xE2, // Usage (Mute),
0x09, 0xCD, // Usage (Play/Pause),
0x09, 0xB5, // Usage (Scan Next Track),
0x09, 0xB6, // Usage (Scan Previous Track),
0x09, 0xB7, // Usage (Stop),
0x09, 0xB8, // Usage (Eject),

Na samym końcu zdefiniowanie ramki do wysłania. Przesyłany będzie numer ID wraz z wprowadzonym klawiszem:

0x81, 0x02, // Input (Data,Var,Abs)
0xC0, //End Collection

Cały deskryptor wygląda następująco:

0x05, 0x0C, //Usage Page (Consumer)
0x09, 0x01, //Usage (Consumer Control)
0xA1, 0x01, //Collection (Application)
0x85, 0x02, // Report ID (2)
0x05, 0x0C, // Usage Page (Consumer)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x75, 0x01, // Report Size (1)
0x95, 0x08, // Report Count (7)
0x09, 0xB5, // Usage (Scan Next Track)
0x09, 0xB6, // Usage (Scan Previous Track)
0x09, 0xB7, // Usage (Stop)
0x09, 0xB8, // Usage (Eject)
0x09, 0xCD, // Usage (Play/Pause)
0x09, 0xE2, // Usage (Mute)
0x09, 0xE9, // Usage (Volume Increment)
0x09, 0xEA, // Usage (Volume Decrement)
0x81, 0x02, // Input (Data,Var,Abs)
0xC0, //End Collection

Teraz ostatni z opisywanych deskryptorów czyli customowy pod aplikację Demonstrator.

Ten deskryptor można znaleźć w dokumentach do programu Demonstrator bądź na różnych stronach w internecie.

Na samym początku otwarcie deskryptora:

0x06, 0x00, 0xff, // USAGE_PAGE (Generic Desktop)
0x09, 0x01, // USAGE (Vendor Usage 1)
0xa1, 0x01, // COLLECTION (Application)

W środku definiujemy deskryptory dla przycisków:

0x85, 0x01, // REPORT_ID (1)
0x09, 0x01, // USAGE (Vendor Usage 1)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // REPORT_COUNT (1)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0x85, 0x01, // REPORT_ID (1)
0x09, 0x01, // USAGE (Vendor Usage 1)
0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol)
0x85, 0x02, // REPORT_ID (2)
0x09, 0x02, // USAGE (Vendor Usage 2)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // REPORT_COUNT (1)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0x85, 0x02, // REPORT_ID (2)
0x09, 0x02, // USAGE (Vendor Usage 2)
0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol)
0x85, 0x03, // REPORT_ID (3)
0x09, 0x03, // USAGE (Vendor Usage 3)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // REPORT_COUNT (1)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0x85, 0x03, // REPORT_ID (3)
0x09, 0x03, // USAGE (Vendor Usage 3)
0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol)
0x85, 0x04, // REPORT_ID (4)
0x09, 0x04, // USAGE (Vendor Usage 4)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // REPORT_COUNT (1)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0x85, 0x04, // REPORT_ID (4)
0x09, 0x04, // USAGE (Vendor Usage 4)
0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol)

Dla wartości USAGE oraz RAPORT_ID wprowadzany jest identyfikator raporty. Diody przyjmują wartości 0 lub 1. Czyli świeci albo nie świeci.

Teraz deskryptor dla dwóch przycisków:

0x85, 0x05, // REPORT_ID (5)
0x09, 0x05, // USAGE (Vendor Usage 5)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x04, // REPORT_COUNT (4)
0x81, 0x82, // INPUT (Data,Var,Abs,Vol)
0x85, 0x06, // REPORT_ID (6)
0x09, 0x06, // USAGE (Vendor Usage 6)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x04, // REPORT_COUNT (4)
0x81, 0x82, // INPUT (Data,Var,Abs,Vol)

Ostania część deskryptora pozwala na przesłanie danych do urządzenia w wartościach od 0 do 255:

0x85, 0x09, // REPORT_ID (9)
0x09, 0x09, // USAGE (someData)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x26, 0xFF, 0x00, // LOGICAL_MAXIMUM (255)
0x75, 0x08, // REPORT_SIZE (8)
0x81, 0x82, // INPUT (Data,Var,Abs,Vol)
0x85, 0x09, // REPORT_ID (9)
0x09, 0x09, // USAGE (someData)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)

Wartość maksymalna Logical_Maximum wartość należy wprowadzić w dwóch polach. Ponieważ dane w polu są typu signed. Co oznacza, że pominięcie wartości 0x00 spowoduje interpretację danych jako -128.

Pełny deskryptor wygląda następująco:

0x06, 0x00, 0xff, // USAGE_PAGE (Generic Desktop)
0x09, 0x01, // USAGE (Vendor Usage 1)
0xa1, 0x01, // COLLECTION (Application)
0x85, 0x01, // REPORT_ID (1)
0x09, 0x01, // USAGE (Vendor Usage 1)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // REPORT_COUNT (1)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0x85, 0x01, // REPORT_ID (1)
0x09, 0x01, // USAGE (Vendor Usage 1)
0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol)
0x85, 0x02, // REPORT_ID (2)
0x09, 0x02, // USAGE (Vendor Usage 2)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // REPORT_COUNT (1)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0x85, 0x02, // REPORT_ID (2)
0x09, 0x02, // USAGE (Vendor Usage 2)
0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol)
0x85, 0x03, // REPORT_ID (3)
0x09, 0x03, // USAGE (Vendor Usage 3)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // REPORT_COUNT (1)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0x85, 0x03, // REPORT_ID (3)
0x09, 0x03, // USAGE (Vendor Usage 3)
0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol)
0x85, 0x04, // REPORT_ID (4)
0x09, 0x04, // USAGE (Vendor Usage 4)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // REPORT_COUNT (1)
0xB1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0x85, 0x04, // REPORT_ID (4)
0x09, 0x04, // USAGE (Vendor Usage 4)
0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol)
0x85, 0x05, // REPORT_ID (5)
0x09, 0x05, // USAGE (Vendor Usage 5)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x04, // REPORT_COUNT (4)
0x81, 0x82, // INPUT (Data,Var,Abs,Vol)
0x85, 0x06, // REPORT_ID (6)
0x09, 0x06, // USAGE (Vendor Usage 6)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x04, // REPORT_COUNT (4)
0x81, 0x82, // INPUT (Data,Var,Abs,Vol)
0x85, 0x09, // REPORT_ID (9)
0x09, 0x09, // USAGE (someData)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x26, 0xff, 0x00, // LOGICAL_MAXIMUM (255)
0x75, 0x08, // REPORT_SIZE (8)
0x81, 0x82, // INPUT (Data,Var,Abs,Vol)
0x85, 0x09, // REPORT_ID (9)
0x09, 0x09, // USAGE (someData)
0xb1, 0x82, // FEATURE (Data,Var,Abs,Vol)
0xC0

Działanie z przykładowym programem:

Teraz kilka funkcji pozwalających na przesłanie customowych danych:

Na samym początku przygotowanie ramki danych do wysłania:

static void sendData(uint8_t reportId, uint8_t data1, uint8_t data2,
uint8_t data3, uint8_t data4)
{
uint8_t dataToSend[5];
dataToSend[0]=reportId;
dataToSend[1]=data1;
dataToSend[2]=data2;
dataToSend[3]=data3;
dataToSend[4]=data4;
USBD_CUSTOM_HID_SendReport(&hUsbDeviceFS,dataToSend,5);
}

Z wykorzystaniem tej funkcji można wysłać większość pakietów. Np uruchomienie przycisku:

sendData(0x05, 0x01, 0xFF, 0xFF, 0xFF); //Enable btn
sendData(0x05, 0x00, 0xFF, 0xFF, 0xFF); //Disable btn
sendData(0x06, 0x01, 0xFF, 0xFF, 0xFF); //Enable second btn
sendData(0x06, 0x00, 0xFF, 0xFF, 0xFF); //Disable second btn

Przesłanie danych z pełnymi wartościami dla jednego bajtu:

sendData(0x09, 0xAA, 0xFF, 0xFF, 0xFF);

Dekodowanie odebranych danych wygląda następująco:

static int8_t CUSTOM_HID_OutEvent_FS (uint8_t event_idx, uint8_t state)
{
/* USER CODE BEGIN 6 */
USBD_CUSTOM_HID_HandleTypeDef *hhid = (USBD_CUSTOM_HID_HandleTypeDef*)hUsbDeviceFS.pClassData;
for (uint8_t i = 0; i < 2; i++)
{
hidRecData[i] = hhid->Report_buf[i];
}
if(hidRecData[0]==1)
{
if (hidRecData[1]==1)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_SET);
}
else if (hidRecData[1]==0)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_RESET);
}
}
else if(hidRecData[0]==2)
{
if (hidRecData[1]==1)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, GPIO_PIN_SET);
}
else if (hidRecData[1]==0)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, GPIO_PIN_RESET);
}
}
else if(hidRecData[0]==3)
{
if (hidRecData[1]==1)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
}
else if (hidRecData[1]==0)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
}
}
else if(hidRecData[0]==4)
{
if (hidRecData[1]==1)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_15, GPIO_PIN_SET);
}
else if(hidRecData[1]==0)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_15, GPIO_PIN_RESET);
}
}
else if(hidRecData[0]==7)
{
if(hidRecData[1]==0xAA)
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_15, GPIO_PIN_SET);
}
else
{
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_15, GPIO_PIN_RESET);
}
}
return (0);
/* USER CODE END 6 */
}

Na samym początku kopiuje otrzymaną ramkę danych składającą się z dwóch bajtów. Następnie sprawdzam otrzymane dane i zapalam odpowiednie diody na płytce discovery.

Po wgraniu danych i uruchomienie programu powinny wyświetlić się parametry połączenia:

Okno aplikacji Demonstrator gdzie istnieje możliwość odczytu danych z mikrokontrolera (Var Input 1 Report ID), przesłania danych z komputera do układu (Variable Output Report ID), sprawdzenie stanu przycisku (Button Report ID) oraz ustawienie diod (Led Report ID)

Można też obejrzeć przesyłaną ramkę danych:

Zwiększanie dźwięku:

Aktualnie korzystam z laptopa z systemem Windows 7. Na nim zmiana dźwięku za pomocą standardowych zestawów klawiszy (czyli 0x7F, 0x80 czy 0x81) okazała się niemożliwa. Mogłem użyć ich jedynie na komputerze stacjonarnym (testowałem tylko na pod Windows 7). Aby użyć tych funkcji na laptopie musiałem wykorzystać lekkie obejście. Najpierw należy utworzyć skrót na pulpicie z lokalizacją: %windir%\System32\SndVol.exe -f 49825268. Będzie on otwierał okno regulacji dźwięku. Dalej klikamy na skrót->właściwości i wprowadzamy klawisz skrótu (ja wykorzystałem F7). Jego kliknięcie wyświetli na ekranie okno regulacji dźwięku. Teraz aby zmienić głośność należy kliknąć strzałkę w górę lub w dół, bądź prawo oraz lewo czy PgUp bądź PdDown czy End w celu kompletnego wyciszenia.

Czyli aby była możliwość zmiany dźwięku na laptopie należy użyć klawisz skrótu, po czym wybrać jeden z klawiszy odpowiedzialnych za operacje do wykonania.

Wobec tego po wykonaniu skrótów głośność można zmodyfikować za pomocą takiej funkcji:

Dla komputera obsługującego klawisze multimedialne można posłużyć się takimi kodami jak:

#define USB_MEDIA_SCAN_NEXT 0x01
#define USB_MEDIA_SCAN_PREV 0x02
#define USB_MEDIA_STOP 0x04
#define USB_MEDIA_EJECT 0x08
#define USB_MEDIA_PAUSE 0x10
#define USB_MEDIA_MUTE 0x20
#define USB_MEDIA_VOL_UP 0x40
#define USB_MEDIA_VOL_DEC 0x80

Struktura przechowująca dane:

typedef struct mediaHidData {
uint8_t reportId;
uint8_t specialKeyData;
}media_Typedef;

Funkcja przesyłająca dane do ustawiania:

void sendMediaData(uint8_t dataSend)
{
media_Typedef mediaReport;
mediaReport.reportId = 0x02;
mediaReport.specialKeyData = dataSend;
USBD_HID_SendReport(&hUsbDeviceFS, (uint8_t*)&mediaReport, sizeof(media_Typedef));
HAL_Delay(30);
mediaReport.reportId = 0x02;
mediaReport.specialKeyData = 0x00;
USBD_HID_SendReport(&hUsbDeviceFS, (uint8_t*)&mediaReport, sizeof(media_Typedef));
HAL_Delay(30);
}
void soundUP()
{
sendMediaData(USB_MEDIA_VOL_UP);
}
void soundDown()
{
sendMediaData(USB_MEDIA_VOL_DEC);
}

Tutaj wybierana jest wartość danych do przesłania, które dodawane są jako argument do struktury przesyłanej w paczce danych do komputera.

Sposób z ustawionym skrótem wygląda następująco:

typedef struct keyboardHidData {
uint8_t id;
uint8_t speciakKey;
uint8_t key1;
uint8_t key2;
uint8_t key3;
uint8_t key4;
uint8_t key5;
uint8_t key6;
}keyboard_Typedef;
void sendKeyboardData(uint8_t keySpecial, uint8_t key1, uint8_t key2, uint8_t key3, uint8_t key4,
uint8_t key5, uint8_t key6)
{
keyboard_Typedef keyboardReport;
keyboardReport.id = 0x01;
keyboardReport.speciakKey = keySpecial;
keyboardReport.key1 = key1;
keyboardReport.key2 = key2;
keyboardReport.key3 = key3;
keyboardReport.key4 = key4;
keyboardReport.key5 = key5;
keyboardReport.key6 = key6;
USBD_HID_SendReport(&hUsbDeviceFS, (uint8_t*)&keyboardReport, sizeof(keyboard_Typedef));
HAL_Delay(80);
keyboardReport.id = 0x01;
keyboardReport.speciakKey = 0;
keyboardReport.key1 = 0;
keyboardReport.key2 = 0;
keyboardReport.key3 = 0;
keyboardReport.key4 = 0;
keyboardReport.key5 = 0;
keyboardReport.key6 = 0;
USBD_HID_SendReport(&hUsbDeviceFS, (uint8_t*)&keyboardReport, sizeof(keyboard_Typedef));
HAL_Delay(30);
}
void updateVolumeCombinationKeys_VolumeUp()
{
sendKeyboardData(0x00, F7_Key, 0x00, 0x00, 0x00, 0x00, 0x00);
sendKeyboardData(0x00, Arrow_Up_Key, 0x00, 0x00, 0x00, 0x00, 0x00);
}
void updateVolumeCombinationKeys_VolumeDown()
{
sendKeyboardData(0x00, F7_Key, 0x00, 0x00, 0x00, 0x00, 0x00);
sendKeyboardData(0x00, Arrow_Down_Key, 0x00, 0x00, 0x00, 0x00, 0x00);
}

W tym przypadku przesyłamy dwa razy pakiet danych do komputera, każdy z osobnym klawiszem.

Projekty do tego postu można pobrać z dysku Google pod tym linkiem.

Bibliografia:

[1] Device Class Definition for Human Interface Devices (HID)
[2] USB HID Descriptor
[3] UM0424 - STM32 USB-FS-Device development kit
[4] EP - Wykorzystaj USB Implementacja klasy HID interfejsu USB w STM32

Elektronika i Programowanie

poniedziałek, 4 czerwca 2018

[35] STM32F4 - Klawiatura, custom HID

Napisanie własnego deskryptora:

Działanie z przykładowym programem:

Zwiększanie dźwięku:

Bibliografia:

Popularne posty

Archiwum bloga

Archiwum bloga