Manuel d'instructions de la pile de périphériques USB SILICON LABS

La pile de périphériques USB de Silicon Labs offre une solution polyvalente et
connectivité USB facile à utiliser pour les projets IoT, facilitant
communication entre les coprocesseurs du réseau et les hôtes.

Caractéristiques

Pile de périphériques USB efficace

Idéal pour les projets IoT
Prise en charge de la communication entre les coprocesseurs du réseau et
hôtes

Instructions d'utilisation du produit

Configuration du périphérique USB

Configurez les paramètres du périphérique USB en fonction de votre projet
exigences en vous référant à la section Configuration du périphérique USB
dans la documentation.

Guide de programmation des périphériques USB

Suivez le guide de programmation du périphérique USB pour comprendre comment
programmer et interagir avec le périphérique USB pour divers
candidatures.

Classes de périphériques USB

La section Classes de périphériques USB fournit un aperçuview de différents
classes telles que CDC ACM, HID, MSC SCSI et Vendor Class. Choisissez
classe appropriée en fonction des fonctionnalités de votre appareil.

Dépannage des périphériques USB

Si vous rencontrez des problèmes avec le périphérique USB, reportez-vous à la
Section de dépannage des périphériques USB pour les solutions et le débogage
conseils.

Hôte USB du système d'exploitation Microsoft Windows

Si vous utilisez le périphérique USB avec un système d'exploitation Microsoft Windows USB
Hôte, assurez-vous de suivre les directives fournies dans le
documentation pour une intégration transparente.

FAQ

Q : Quels sont les ex courantsamples appareils que je peux construire en utilisant
cette pile USB ?

A : La pile USB vous permet de construire des appareils tels que
Adaptateurs USB vers série, souris ou claviers, stockage amovible
appareils et appareils personnalisés.

Q : Existe-t-il des exigences logicielles spécifiques pour utiliser ce produit ?
Pile de périphériques USB ?

R : Les logiciels compatibles incluent Simplicity SDK, Simplicity
Studio, Simplicity Commander, GCC (la collection de compilateurs GNU),
IAR Embedded Workbench pour ARM et IAR EWARM.

View Fullscreen

Bus série universel USB

USB surview Surview
Notes de version USB
Spécifications et fonctionnalitésview
Configuration du périphérique USB terminéeview
Guide de programmation des périphériques USBview
Classes de périphériques USB terminéesview Classe CDC ACM terminéeview Classe HID terminéeview Classe MSC SCSI terminéeview Classe de fournisseur terminéeview
Documentation de l'API API de périphérique USB API ACM de périphérique USB a sl_usbd_cdc_ cm_line_coding_t sl_usbd_cdc_acm_callbacks_t API CDC de périphérique USB a sl_usbd_cdc_subcl ss_driver_t API principale de périphérique USB
sl_usbd_device_config_t sl_usbd_setup_req_t
une API HID de périphérique USB sl_usbd_cl ss_driver_t
API MSC du périphérique USB sl_usbd_hid_callbacks_t
un périphérique USB sl_usbd_msc_subcl ss_driver_t API SCSI MSC
sl_usbd_msc_scsi_callbacks_t

1/174

Bus série universel USB
un sl_usbd_msc_scsi_lun_pi
sl_usbd_msc_scsi_lun_info sl_usbd_msc_scsi_lun
API du fournisseur de périphériques USB sl_usbd_vendor_callbacks_t
Documentation API Dépannage des périphériques USB
Surview Hôte USB du système d'exploitation Microsoft Windows
Surview

2/174

Surview
Surview
Périphérique USB
L'USB est l'une des interfaces de communication les plus performantes de l'histoire des systèmes informatiques et constitue la norme de facto pour la connexion de périphériques. La pile de périphériques USB Silicon Labs est un module USB spécialement conçu pour les systèmes embarqués. Conçue dès le départ avec la qualité, l'évolutivité et la fiabilité de Silicon Labs, elle a subi un processus de validation rigoureux pour garantir sa conformité à la spécification USB 2.0. Cette documentation décrit l'initialisation, le démarrage et l'utilisation de la pile de périphériques USB Silicon Labs. Elle explique les différentes valeurs de configuration et leurs utilisations. Elle inclut également une vue d'ensemble.view de la technologie, des types de possibilités de configuration, des procédures de mise en œuvre et des exemplesamples d'utilisation typique pour chaque classe disponible.
Pour vous aider à comprendre rapidement les concepts USB, la documentation propose de nombreux exemplesamples USB avec fonctions de base. Ces exampLes vous fourniront un cadre qui vous permettra de construire rapidement des appareils. Ces exemplesamples incluent :
Adaptateur USB-série (classe de périphérique de communication) Souris ou clavier (classe de périphérique d'interface humaine) Périphérique de stockage amovible (classe de stockage de masse) Périphérique personnalisé (classe de fournisseur)
Ce qui suit est terminéview des sections de la documentation :
Spécifications et fonctionnalités Configuration du périphérique USB Guide de programmation du périphérique USB Classes de périphériques USB
Classe CDC ACM Classe HID Classe MSC SCSI Classe fournisseur Dépannage du périphérique USB Système d'exploitation Microsoft Windows Hôte USB

3/174

USB
USB

Version USB 1.5.1 (21 juillet 2025) – Notes de publication
Version 2025.6.1 du SDK Simplicity
La pile de périphériques USB performante de Silicon Labs offre une connectivité USB polyvalente et facile à utiliser, idéale pour les projets IoT, notamment la communication entre les coprocesseurs réseau et les hôtes. Cliquez ici pour consulter les versions antérieures.
Résumé de la publication
Fonctionnalités clés | Modifications de l'API | Corrections de bugs | Activation de la puce
Caractéristiques principales
Modifications de la plateforme sous-jacente uniquement.
Modifications de l'API
Aucun.
Corrections de bugs
Aucun.
Activation de la puce
Aucun.
Caractéristiques principales
Nouvelles fonctionnalités | Améliorations | Fonctionnalités supprimées | Fonctionnalités obsolètes
Nouvelles fonctionnalités
Aucun.
Améliorations
Modifications de la plateforme sous-jacente uniquement.
Fonctionnalités supprimées
Aucun.
Fonctionnalités obsolètes
Aucun.
Modifications de l'API
Nouvelles API | API modifiées | API supprimées | API obsolètes
Nouvelles API

4/174

USB
Aucun.
API modifiées
Aucun.
API supprimées
Aucun.
API obsolètes
Aucun.
Corrections de bugs
Aucun.
Activation de la puce
Aucun.
Demande Examples changements
Nouvel examples | Ex modifiéamples | Ex suppriméamples | Ex obsolèteamples
Nouvel examples
Aucun.
Ex modifiéamples
Aucun.
Ex suppriméamples
Aucun.
Ex obsolèteamples
Aucun.
Impact des modifications de version
Déclarations d'impact | Guide de migration
Déclarations d'impact
Aucun.
Guide de migration
Aucun.
Problèmes connus et limitations
Aucun.
Utilisation de cette version

5/174

USB

Contenu de la version ? | Logiciels compatibles | Installation et utilisation | Aide et commentaires

Que contient le communiqué ?

Application de pile de périphériques USB Examples
Logiciels compatibles

Logiciel
Simplicity SDK Simplicity Studio Simplicity Commander GCC La collection de compilateurs GNU) IAR Embedded Workbench pour ARM IAR EWARM

Version ou variante compatible
2025.6.0 5.11.0 1.18.2 (fourni avec Simplicity Studio) 12.2.1 (fourni avec Simplicity Studio) 9.40.1 (fourni avec Simplicity Studio)

Installation et utilisation

Pour démarrer votre développement, consultez notre :
Guide de programmation des périphériques USB. Documentation API.
Pour plus d'informations sur l'intégration de Secure Vault, voir Secure Vault.
Pour review Notifications de sécurité et d'avis logiciels et gestion de vos préférences de notification :
ò Allez sur https://community.silabs.com/. ó Connectez-vous avec vos identifiants de compte. ô Cliquez sur votre profile icône dans le coin supérieur droit de la page.
õ Sélectionnez Notifications dans le menu déroulant. ö Dans la section Notifications, accédez à l'onglet Mes notifications de produit pourview avis historique sur la sécurité et les logiciels
notifications
÷ Pour gérer vos préférences, utilisez l'onglet Gérer les notifications pour personnaliser les mises à jour et les avis de produits que vous souhaitez recevoir.
recevoir.
Pour les paramètres de configuration recommandés, voir ici.
Pour en savoir plus sur les logiciels de cette version, plongez dans notre documentation en ligne.
Aide et commentaires

Contactez l'assistance Silicon Labs. Pour obtenir des réponses à vos questions via notre outil « Ask AI », utilisez le champ de recherche en haut de cette page.

Remarque : Ask AI est expérimental.

Obtenez de l'aide de notre communauté de développeurs.
Politique de publication et de maintenance du SDK
Consultez notre politique de publication et de maintenance du SDK.

6/174

Surview
Surview
Caractéristiques
Conforme à la « spécification Universal Serial Bus révision 2.0 » Implémente l'« Interface Association Descriptor Engineering Change Notice (ECN) » Types de transfert
Contrôle des interruptions en masse Classes USB Classe de périphérique de communication (CDC) Modèle de contrôle abstrait (ACM) Périphérique d'interface humaine (HID) Classe de stockage de masse (MSC) Cadre de classe spécifique au fournisseur
Caractéristiques
Évolutif pour inclure uniquement les fonctionnalités requises afin de minimiser l'empreinte mémoire Prend en charge la pleine vitesse (12 Mbit/s) Prend en charge les périphériques composites (multifonctions) Prend en charge les périphériques multi-configuration Prend en charge les fonctionnalités d'économie d'énergie USB (suspension et reprise de l'appareil) Intégration complète de la classe de stockage de masse dans Micrium OS File Module système développé avec la couche d'abstraction CMSIS-RTOS2 pour fonctionner avec différents systèmes d'exploitation. Le GSDK de Silicon Labs inclut les ports FreeRTOS et Micrium OS.

7/174

Surview
Surview

Configuration du périphérique USB

Cette section explique comment configurer le périphérique USB Silicon Labs. Il existe trois groupes de paramètres de configuration :
Configuration du noyau du périphérique USB Configuration des informations du périphérique USB Configuration matérielle du périphérique USB
Configuration du cœur du périphérique USB
Le périphérique USB Silicon Labs peut être configuré au moment de la compilation via un ensemble de #defines situé dans le fichier sl_usbd_core_config.h fileLe périphérique USB utilise des définitions #defines lorsque cela est possible, car elles permettent d'adapter la taille du code et des données à la compilation en fonction des fonctionnalités activées. Cela permet d'ajuster les empreintes de mémoire morte (ROM) et de mémoire vive (RAM) du périphérique USB Silicon Labs en fonction des besoins de votre application.
Recommandé : démarrez le processus de configuration avec les valeurs par défaut (surlignées en gras).
Les sections ci-dessous sont organisées en fonction de l'ordre dans la configuration du modèle file, sl_usbd_core_config.h.
Configuration des classes de configuration de base
Configuration de base
Tableau – Constantes de configuration du cœur du périphérique USB

Description constante

Valeur par défaut

SL_USBD_TA SK_STACK_TAILLE

Configure la taille de la pile en octets de la tâche principale USBD

4096

SL_USBD_TA SK_PRIORIT Y

Configure la priorité de la tâche principale USBD. Il s'agit d'une priorité CMSIS-RTOS2.

osPrioritéÉlevée

SL_USBD_A UTO_START _APPAREIL_USB E

Si cette option est activée, le périphérique USB sera automatiquement démarré dès le démarrage du noyau et la première tâche du noyau USBD sera planifiée. Si elle est désactivée, votre application devra appeler sl_usbd_core_start_device() lorsqu'elle sera prête à être détectée par l'hôte USB.

SL_USBD_C Le nombre total de configurations qui seront ajoutées via sl_usbd_add_configuration()

Fonction ONFIGURATI.

ON_QUANTI

8/174

Surview

Constante
SL_USBD _INTERF ACE_QU ANTITÉ
SL_USBD _ALT_INT ERFACE_ QUANTI
TY
SL_USBD _INTERFACE_GR
OUP_QU
ANTITÉ
SL_USBD _DESCRI
PTOR_Q
UANTITÉ
SL_USBD _STRING _QUANTI
TY
SL_USBD _OPEN_ENDPOIN TS_QUA NTITY

Description : nombre total d'interfaces USB à ajouter pour toutes vos configurations. Cela dépend fortement de la ou des classes utilisées. Pour plus d'informations sur le nombre d'interfaces requis par une instance de classe, consultez la section « Besoins en ressources du noyau » de votre ou vos classes.
Nombre total d'interfaces USB alternatives à ajouter pour toutes vos configurations. Cela dépend fortement de la ou des classes utilisées. Cette valeur doit toujours être supérieure ou égale à SL_USBD_INTERFACE_QUANTITY. Pour plus d'informations sur le nombre d'interfaces alternatives requis par une instance de classe, consultez la section « Besoins en ressources du noyau » de votre ou vos classes.
Le nombre total de groupes d'interfaces USB à ajouter à toutes vos configurations. Cela dépend fortement de la ou des classes utilisées. Pour plus d'informations sur le nombre de groupes d'interfaces requis par une instance de classe, consultez la section « Besoins en ressources du noyau » de votre ou vos classes.
Le nombre total de descripteurs de points de terminaison à ajouter à toutes vos configurations. Cela dépend fortement de la ou des classes utilisées. Pour plus d'informations sur le nombre de descripteurs de points de terminaison requis par une instance de classe, consultez la section « Nombre de points de terminaison » de la section « Besoins en ressources du noyau » de votre ou vos classes. Notez que les points de terminaison de contrôle ne sont pas à prendre en compte ici. Le nombre total de chaînes USB. Définir la quantité à zéro désactivera la fonctionnalité. La désactivation de cette option empêchera le périphérique de stocker les chaînes de description USB transmises par l'application. Cela signifie que l'hôte ne pourra pas récupérer les chaînes de description (telles que le fabricant et le nom du produit). Le nombre total de points de terminaison ouverts par configuration. Un périphérique nécessite au moins deux points de terminaison ouverts pour les transferts de contrôle, mais vous devez également ajouter les points de terminaison de la ou des classes utilisées. Pour plus d'informations sur le nombre de points de terminaison ouverts requis par une instance de classe, consultez la section « Nombre de points de terminaison » de la section « Besoins en ressources du noyau » de votre ou vos classes.

Valeur par défaut
10 10
2
20 30 20

Configuration des classes
Les classes ont des configurations de compilation spécifiques. Consultez la section « Classes de périphériques USB » pour plus d'informations.
Configuration des informations sur le périphérique USB

La configuration sl_usbd_device_config.h file regroupe les définitions de compilation #define-s pour définir les informations de base concernant votre appareil, telles que l'ID du fournisseur/produit, les chaînes de l'appareil, etc. Le tableau ci-dessous décrit chaque définition de configuration d'informations disponible dans cette configuration file.

Tableau – Définitions de configuration des informations sur les périphériques USB

Constante
SL_USBD_DEVIC E_VENDOR_ID
SL_USBD_DEVIC E_PRODUCT_ID

Description : Votre numéro d'identification de fournisseur, tel que fourni par l'USB Implementers Forum. Pour plus d'informations sur l'obtention d'un identifiant de fournisseur, consultez http://www.usb.org/developers/vendor/. Votre numéro d'identification de produit.

9/174

Surview

Constante

Description

SL_USBD_DEVICE_RELEASE Numéro de version de votre appareil. _NUMBER

SL_USBD_DEVICE_MANUFA Chaîne décrivant le fabricant de votre appareil. Cette configuration est ignorée lorsque

CTURER_STRING

la configuration SL_USBD_STRING_QUANTITY est définie sur 0.

SL_USBD_DEVICE_PRODUC Chaîne décrivant votre produit. Cette configuration est ignorée lors de la configuration.

T_STRING

SL_USBD_STRING_QUANTITY est défini sur 0.

SL_USBD_DEVICE_SERIAL_N Chaîne contenant le numéro de série de votre appareil. Cette configuration est ignorée lorsque

CHAÎNE_NUMÉRO

la configuration SL_USBD_STRING_QUANTITY est définie sur 0.

SL_USBD_DEVICE_LANGUA : Numéro d'identification de la langue des chaînes de votre appareil. Valeurs possibles :
GE_ID

– SL_USBD_LANG_ID_ARABIC_SAUDI_ARABIA

– SL_USBD_LANG_ID_CHINESE_TAIWAN

– SL_USBD_LANG_ID_ANGLAIS_US

– SL_USBD_LANG_ID_ANGLAIS_UK

– SL_USBD_LANG_ID_FRANÇAIS

– SL_USBD_LANG_ID_ALLEMAND

– SL_USBD_LANG_ID_GREC

– SL_USBD_LANG_ID_ITALIEN

– SL_USBD_LANG_ID_PORTUGAIS

– SL_USBD_LANG_ID_SANSKRIT

Cette configuration est ignorée lorsque la configuration SL_USBD_STRING_QUANTITY est définie sur 0.

Configuration matérielle du périphérique USB

Selon l'appareil Silicon Labs utilisé, vous disposerez probablement de la broche et du port GPIO à configurer pour le signal USB VBUS Sense. Les définitions de configuration se trouvent dans l'en-tête sl_usbd_hardware_config.h. file.

Constante
SL_USBD_DRIVER_VBUS_SENSE_PORT SL_USBD_DRIVER_VBUS_SENSE_PIN

Description
Port GPIO pour le signal USB VBUS Sense sur votre carte. Broche GPIO pour le signal USB VBUS Sense sur votre carte.

10/174

Surview
Surview
Guide de programmation des périphériques USB
Cette section explique comment utiliser le module Périphérique USB.
Configuration initiale du module de périphérique USB
Cette section décrit les étapes de base nécessaires à l'initialisation du module Périphérique USB et à l'ajout, la préparation et le démarrage d'un périphérique. Initialisation du module Périphérique USB Initialisation du noyau du périphérique USB Initialisation des aCl ss Ajout de votre périphérique USB Construction de votre périphérique USB Ajout de configurations Ajout de fonctions USB Démarrage de votre périphérique USB
Fonctions de hook d'événement
Initialisation du module de périphérique USB
Initialisation du noyau du périphérique USB
a US a Commencez par initialiser le module de périphérique B en appelant la fonction sl_usbd_core_init() . L'exemple ci-dessous montre l'appel de sl_usbd_core_init() .
Example – Appel de sl_usbd_core_init()
sl_status_t status; status = sl_usbd_core_init(); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}
Initialisation de la ou des classes
Une fois le module principal du périphérique USB initialisé, vous devez initialiser chaque classe que vous souhaitez utiliser. Consultez la section « Guide de programmation » de votre fichier ACL pour plus d'informations.
Construire votre périphérique USB
Ajout de configuration(s)
Après avoir initialisé votre périphérique, vous pouvez commencer à lui ajouter des fonctions USB, en commençant par une nouvelle configuration. Un périphérique doit posséder au moins une configuration. Pour ajouter une ou plusieurs configurations, appelez la fonction sl_usbd_core_dd_configuration(). Cette fonction doit être appelée pour chaque configuration à ajouter. L'exempleampci-dessous montre comment ajouter une vitesse complète.
Example – Ajout de configuration(s) à votre appareil

11/174

Surview

statut sl_status_t; uint8_t config_nbr_fs;

/* Ajout d'une configuration pleine vitesse au périphérique. */

statut = sl_usbd_core_add_configuration(0,

/* Aucun attribut spécial à la configuration. */

100u,

/* Consommation électrique maximale : 100 mA.

SL_USBD_DEVICE_SPEED_FULL,

/* Configuration pleine vitesse.

« Configurer Ajouter Exampla configuration Full-Speed”,

&config_nbr_fs);

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

Ajout de fonctions USB
Après avoir ajouté au moins une configuration à votre appareil, vous pouvez ajouter les interfaces et les points de terminaison. Chaque classe USB a ses propres besoins en termes de type, de quantité et d'autres paramètres d'interface et de points de terminaison. Silicon Labs USB Device ajoute des interfaces et des points de terminaison aux classes qu'il propose.
Depuis votre application, vous pouvez instancier une classe USB et l'ajouter à une configuration. Pour plus d'informations sur le concept d'instances de classe de périphérique USB, consultez la section « Classes de périphériques USB ». Notez que vous pouvez instancier et ajouter de nombreuses instances de classe différentes à une configuration pour créer un périphérique multifonction (composite).
L'exampCe qui suit montre comment créer une instance de classe et l'ajouter à une configuration.
Example – Ajout d'une instance de classe à votre appareil

sl_status_t statut; uint8_t class_nbr;
/* Créez une instance de la classe que vous souhaitez utiliser.*/ /* Notez que selon la classe, cette fonction peut avoir plus d'arguments. */ status = sl_usbd_ _create_instance(&class_nbr); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */ }
/* Ajoutez l'instance de classe à la configuration Full-Speed. */ status = sl_usbd_ _add_to_configuration(class_nbr, /* Numéro de classe renvoyé par sl_usbd_ _créer_instance. */
config_nbr_fs); /* Numéro de configuration renvoyé par sl_usbd_core_add_configuration(). */ if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */ }
Démarrage de votre périphérique USB
Par défaut, le périphérique est démarré automatiquement par la tâche principale du périphérique USB une fois son initialisation terminée et le noyau démarré. Pour contrôler le moment où le périphérique démarre et devient visible par l'hôte USB, utilisez la définition de configuration SL_USBD_AUTO_START_USB_DEVICE pour désactiver la fonctionnalité de démarrage automatique. Une fois cette fonction désactivée, après avoir compilé/préparé votre périphérique, vous pouvez le démarrer et le rendre visible par l'hôte USB en appelant la fonction sl_usbd_core_start_device().
L'exampCe qui suit montre comment démarrer votre appareil à l'aide de la fonction sl_usbd_core_start_device().
Example – Démarrage de votre appareil

12/174

Surview

sl_status_t statut;
status = sl_usbd_core_start_device(); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */ }

Fonctions de hook d'événement
Le module principal du périphérique USB propose deux fonctions de hook faible que vous pouvez redéfinir dans votre application. Leur objectif est de notifier les événements de bus et de configuration qui se produisent.
Tableau – Fonctions du crochet d'événement USB

Événement

Description

Bus

Appelé lorsque l'événement du bus USB se produit

Configuration appelée lorsque l'événement de configuration USB se produit

Signature de fonction
void sl_usbd_on_bus_event(sl_usbd_bus_event_t événement); void sl_usbd_on_config_event(sl_usbd_config_event_t événement, uint8_t config_nbr);

Example – Fonctions de hook d'événement

void sl_usbd_on_bus_event(sl_usbd_bus_event_t event) { switch (événement) { case SL_USBD_EVENT_BUS_CONNECT :
// appelé lorsque le câble USB est inséré dans un contrôleur hôte break;
case SL_USBD_EVENT_BUS_DISCONNECT : // appelé lorsque le câble USB est retiré d'un contrôleur hôte break ;
case SL_USBD_EVENT_BUS_RESET : // appelé lorsque l'hôte envoie la commande de réinitialisation break ;
case SL_USBD_EVENT_BUS_SUSPEND : // appelé lorsque l'hôte envoie la commande de suspension break ;
case SL_USBD_EVENT_BUS_RESUME : // appelé lorsque l'hôte envoie une commande de réveil break ;
par défaut : break ; } }
void sl_usbd_on_config_event(sl_usbd_config_event_t événement, uint8_t config_nbr) { switch (événement) { case SL_USBD_EVENT_CONFIG_SET :
// appelé lorsque l'hôte définit une rupture de configuration ;
case SL_USBD_EVENT_CONFIG_UNSET : // appelé lorsqu'une configuration n'est pas définie break ;
par défaut : break ; } }

13/174

Surview

14/174

Surview
Surview

Classes de périphériques USB

Les classes USB disponibles dans Silicon Labs USB Device partagent des caractéristiques communes. Cette section explique ces caractéristiques et leurs interactions avec la couche cœur.
Pour plus d'informations sur une classe spécifique, consultez les éléments suivants :
Classe CDC ACM Classe HID Classe MSC SCSI Classe fournisseur
À propos des instances de classe
Les classes USB disponibles dans USB Device implémentent le concept d'instances de classe. Une instance de classe représente une fonction au sein d'un périphérique. Cette fonction peut être décrite par une interface ou un groupe d'interfaces et appartient à une classe spécifique.
Chaque implémentation de classe USB partage certaines configurations et fonctions, basées sur le concept d'instance de classe. Les configurations et fonctions communes sont présentées dans le tableau ci-dessous. Dans la colonne « Constantes ou Fonction », l'espace réservé XXXX peut être remplacé par le nom de la classe : CDC, HID, MSC, CDC_ACM ou VENDOR (fournisseur pour les noms de fonctions).
Tableau – Constantes et fonctions liées au concept d'instances de classe multiples

Constante ou fonction
SL_USBD_XXXX_CL ASS_INS TANCE_QUANTITÉ
SL_USBD_XXXX_CONFIGUR ATION_QUANTITÉ
sl_usb d _XXXX_cre ate _insta nce()
sl_usbd_XXXX_add_to_configuration()

Description
Configure le nombre maximal d'instances de classe.
Configure le nombre maximal de configurations. Lors de l'initialisation de la classe, une instance de classe créée est ajoutée à une ou plusieurs configurations. Crée une nouvelle instance de classe.
Ajoute une instance de classe existante à la configuration de périphérique spécifiée.

En termes d'implémentation du code, la classe déclarera une variable globale locale contenant une structure de contrôle de classe. Cette structure est associée à une instance de classe et contiendra des informations spécifiques pour gérer cette instance.
Les figures suivantes illustrent plusieurs scénarios. Chaque figure inclut un exemple de code.ample qui correspond au scénario du cas.
Figure – Instances de classe multiples – Le périphérique FS (1 configuration avec 1 interface) représente un périphérique USB classique. Ce périphérique est de type Full-Speed (FS) et possède une configuration unique. Sa fonction est décrite par une interface composée de deux points de terminaison pour la communication de données. Une instance de classe est créée et permet de gérer l'interface complète avec son point de terminaison associé.
Figure – Instances de classe multiples – Configuration du périphérique FS 1 avec 1 interface)

15/174

Surview

Le code correspondant à la Figure – Instances de classe multiples – Périphérique FS (1 configuration avec 1 interface) est affiché dans l'exempleample ci-dessous.
Example – Instances de classe multiples – Configuration du périphérique FS 1 avec 1 interface)

sl_status_t statut; uint8_t classe_0;

void app_usbd_XXXX_enable(uint8_t class_nbr) { /* Gérer l'événement d'activation de classe. */ }

void app_usbd_XXXX_disable(uint8_t class_nbr) { /* Gérer l'événement de désactivation de classe. */ }

sl_usbd_XXXX_callbacks_t classe_callbacks = {

(1)

.enable = app_usbd_XXXX_enable,

.disable = app_usbd_XXXX_disable

};

statut = sl_usbd_XXXX_init();

(2)

si (statut ! SL_STATUS_OK) {

/* $$$$ Gère l'erreur. */

}

statut = sl_usbd_XXXX_create_instance(&class_callbacks,

(3)

&class_0);

si (statut ! SL_STATUS_OK) {

/* $$$$ Gère l'erreur. */

}

statut = sl_usbd_XXXX_add_to_configuration(classe_0, config_0);

(4)

si (statut ! SL_STATUS_OK) {

/* $$$$ Gère l'erreur. */

}

(1) Chaque classe offre un ensemble de fonctions de rappel pour les événements de connexion/déconnexion des appareils et pour les événements spécifiques à la classe. L'objet de structure de rappel est passé en argument lors de la création de l'instance de classe avec la fonction sl_usbd_XXXX_create_instance().
fonction.
(1) Initialiser la classe. Toutes les variables internes, structures et ports de classe seront initialisés. Notez que la fonction Init() de certaines classes peut accepter d'autres arguments.

16/174

Surview
(2) Créez l'instance de classe, class_0. La fonction sl_usbd_XXXX_create_instance() alloue une structure de contrôle de classe associée à class_0. Selon la classe, sl_usbd_XXXX_create_instance() peut avoir des paramètres supplémentaires, outre le numéro de classe, qui représentent des informations spécifiques à la classe stockées dans la structure de contrôle de classe. aaa (3) Ajoutez l'instance de classe, class_0, au numéro de configuration spécifié, config_0. sl_usbd_XXXX_add_to_configuration() créera l'interface 0 et ses points de terminaison IN et OUT associés. Par conséquent, l'instance de classe englobe l'interface 0 et ses points de terminaison. Toute communication effectuée sur l'interface 0 utilisera le numéro d'instance de classe, class_0. La figure – Instances de classe multiples – Périphérique FS (2 configurations et plusieurs interfaces) représente un exemple plus complexe.ampUn périphérique à pleine vitesse est composé de deux configurations. Le périphérique possède deux fonctions appartenant à la même classe, mais chaque fonction est décrite par deux interfaces et possède une paire de points d'extrémité bidirectionnels. Dans cet exempleampDeux instances de classe sont créées. Chaque instance est associée à un groupe d'interfaces, contrairement aux figures « Instances de classe multiples – Périphérique FS (1 configuration avec 1 interface) » et « Instances de classe multiples – Périphérique FS (2 configurations et plusieurs interfaces) », où l'instance était associée à une seule interface.
Figure – Instances de classe multiples – Configurations du périphérique FS 2 et interfaces multiples)

Le code correspondant à la Figure – Instances de classe multiples – Périphérique FS (2 configurations et interfaces multiples) est affiché dans l'exempleampci-dessous. La gestion des erreurs est omise pour plus de clarté.
Example – Instances de classe multiples – Configurations du périphérique FS 2 et interfaces multiples)

17/174

Surview

sl_status_t statut; uint8_t classe_0; uint8_t classe_1;
statut = sl_usbd_XXXX_init();
statut = sl_usbd_XXXX_create_instance(&class_0); statut = sl_usbd_XXXX_create_instance(&class_1);
statut = sl_usbd_XXXX_add_to_configuration(classe_0, cfg_0); statut = sl_usbd_XXXX_add_to_configuration(classe_1, cfg_0);
statut = sl_usbd_XXXX_add_to_configuration(classe_0, cfg_1); statut = sl_usbd_XXXX_add_to_configuration(classe_1, cfg_1);

(1)
(2 3) (XNUMX)
(4 5) (XNUMX)
(6 6) (XNUMX)

(1) Initialiser la classe. Toutes les variables internes, structures et ports de classe seront initialisés.
(2) Créez l'instance de classe class_0. La fonction sl_usbd_XXXX_create_instance() alloue une structure de contrôle de classe associée à class_0.
(3) Créez l'instance de classe class_1. La fonction sl_usbd_XXXX_create_instance() alloue une autre structure de contrôle de classe associée à class_1.
(4) Ajoutez l'instance de classe class_0 à la configuration cfg_0. La fonction sl_usbd_XXXX_add_to_configuration() crée les interfaces 0 et 1, les interfaces alternatives et les points de terminaison IN et OUT associés. Le numéro d'instance de classe class_0 sera utilisé pour toute communication de données sur l'interface 0 ou 1.
(5) Ajoutez l'instance de classe class_1 à la configuration cfg_0. La fonction sl_usbd_XXXX_add_to_configuration() crée les interfaces 2 et 3, ainsi que leurs points de terminaison IN et OUT associés. Le numéro d'instance de classe class_1 sera utilisé pour toute communication de données sur les interfaces 2 et 3.
(6) Ajoutez les mêmes instances de classe, class_0 et class_1 , à l'autre configuration, cfg_1 .
Chaque classe définit une structure de type sl_usbd_XXXX_callbacks_t. Son objectif est de fournir à chaque classe un ensemble de fonctions de rappel à appeler lorsqu'un événement se produit. Chaque classe possède deux fonctions de rappel. Elles sont présentées dans le tableau ci-dessous.
Tableau – Fonctions de rappel de classe courantes

Champs Description .enable Appelé lorsque l'instance de classe USB est activée avec succès. .disable Appelé lorsque l'instance de classe USB est désactivée.

Signature de fonction void app_usbd_XXXX_enable(uint8_t class_nbr); void app_usbd_XXXX_disable(uint8_t class_nbr);

18/174

Surview
Surview
Périphérique USB CDC Classe ACM
Classe de base CDC du périphérique USB terminéeview Besoins en ressources de la classe CDC ACM du périphérique USB à partir de la sous-classe CDC ACM du périphérique USB principalview Configuration de la classe CDC ACM du périphérique USB Guide de programmation de la classe CDC ACM du périphérique USB
Cette section décrit la classe CDC (Communications Device Class) et la sous-classe CDC associée prises en charge par la pile USB Device de Silicon Labs. Silicon Labs USB-Device prend actuellement en charge la sous-classe ACM (Abstract Control Model), couramment utilisée pour l'émulation série.
Le CDC comprend divers équipements de télécommunication et de réseau. Les équipements de télécommunication comprennent les modems analogiques, les téléphones analogiques et numériques, les adaptateurs de terminaux RNIS, etc. Par exempleampLes périphériques réseau comprennent les modems ADSL et câble, les adaptateurs Ethernet et les concentrateurs. Le CDC définit un cadre pour encapsuler les normes de services de communication existantes, telles que V.250 (pour les modems sur réseau téléphonique) et Ethernet (pour les périphériques de réseau local), via une liaison USB. Un périphérique de communication est chargé de la gestion des périphériques, de la gestion des appels si nécessaire et de la transmission des données.
Le CDC définit sept grands groupes de périphériques. Chaque groupe appartient à un modèle de communication, qui peut inclure plusieurs sous-classes. Chaque groupe de périphériques possède son propre document de spécification, en plus de la classe de base du CDC. Les sept groupes sont :
Réseau téléphonique public commuté (RTPC), incluant les modems à bande vocale, les téléphones et les dispositifs d'émulation série. Réseau numérique à intégration de services (RNIS), incluant les adaptateurs de terminaux et les téléphones. Dispositifs Ethernet Control Model (ECM), incluant les dispositifs compatibles avec la famille IEEE 802 (ex. : modems câble et ADSL, adaptateurs Wi-Fi). Dispositifs ATM (modem de transfert asynchrone), incluant les modems ADSL et autres dispositifs connectés aux réseaux ATM (postes de travail, routeurs, commutateurs LAN). Dispositifs de communications mobiles sans fil (WMC), incluant les combinés multifonctions utilisés pour gérer les communications voix et données. Dispositifs Ethernet Emulation Model (EEM) échangeant des données en trame Ethernet. Dispositifs NCM (modèle de contrôle réseau), incluant les dispositifs réseau haut débit (modems d'accès par paquets haut débit, équipements terminaux de ligne).
Le CDC et l'implémentation de la sous-classe associée sont conformes aux spécifications suivantes :
Universal Serial Bus, définitions de classe pour les périphériques de communication, révision 1.2, 3 novembre 2010. Universal Serial Bus, communications, sous-classe pour les périphériques PSTN, révision 1.2, 9 février 2007.
Classe de base CDC du périphérique USB terminéeview
Un dispositif CDC est composé des interfaces suivantes pour mettre en œuvre la capacité de communication :
L'interface de classe de communication (CCI) est responsable de la gestion des appareils et, éventuellement, de la gestion des appels.
La gestion des appareils permet la configuration et le contrôle généraux de l'appareil, ainsi que la notification des événements à l'hôte. La gestion des appels permet l'établissement et la terminaison des appels. La gestion des appels peut être multiplexée via une DCI. Une CCI est obligatoire pour tous les appareils CDC. Elle identifie la fonction CDC en spécifiant le modèle de communication pris en charge par l'appareil CDC. La ou les interfaces suivant la CCI peuvent être n'importe quelle interface de classe USB définie, telle qu'une interface audio, ou une interface spécifique au fournisseur. Cette interface spécifique au fournisseur est représentée par une DCI.
L'interface de classe de données (DCI) est responsable de la transmission des données. Les données transmises et/ou reçues ne suivent pas de protocole spécifique.
format. Les données peuvent être des données brutes provenant d'une ligne de communication, des données suivant un format propriétaire, etc. Toutes les DCI suivant le CCI peuvent être considérées comme des interfaces subordonnées.
Un périphérique CDC doit posséder au moins un CCI et zéro, ou plusieurs DCI. Un CCI et tout DCI subordonné fournissent ensemble une fonctionnalité à l'hôte. Cette capacité est également appelée fonction. Dans un périphérique composite CDC, vous pouvez en avoir plusieurs.

19/174

Surview
fonctions. Par conséquent, le dispositif serait composé de plusieurs ensembles de CCI et de DCI(s), comme illustré dans la figure – Dispositif composite CDC.
Figure – Dispositif composite CDC

Un dispositif CDC est susceptible d’utiliser la combinaison de points de terminaison suivante :
Une paire de points de terminaison d'entrée et de sortie de contrôle, appelés points de terminaison par défaut. Un point de terminaison d'entrée optionnel, en bloc ou par interruption. Une paire de points de terminaison d'entrée et de sortie en bloc ou isochrones. Notez que la pile de périphériques USB Silicon Labs ne prend actuellement pas en charge les points de terminaison isochrones.
Le tableau ci-dessous montre l'utilisation des différents points de terminaison et par quelle interface du CDC ils sont utilisés.
Tableau – Utilisation des points de terminaison du CDC

Point final
Contrôle IN
Contrôle SORTIE
Interruption ou en vrac EN vrac ou isochrone EN vrac ou isochrone
DEHORS

Direction
Appareil vers hôte
Hôte à appareil
Appareil vers hôte
Appareil vers hôte
Hôte à appareil

Utilisation de l'interface

CCI

Demandes standard d'énumération, demandes spécifiques à une classe, périphérique

gestion, et éventuellement gestion des appels.

CCI

Demandes standard d'énumération, demandes spécifiques à une classe, périphérique

gestion, et éventuellement gestion des appels.

CCI

Notification d'événements, tels que la détection de sonnerie, l'état de la ligne série, l'état du réseau.

DCI

Communication de données brutes ou formatées.

DCI

Communication de données brutes ou formatées.

La plupart des appareils de communication utilisent un point d'interruption pour notifier l'hôte des événements. Les points d'interruption isochrones ne doivent pas être utilisés pour la transmission de données lorsqu'un protocole propriétaire repose sur la retransmission des données en cas d'erreur de protocole USB. Une communication isochrone peut intrinsèquement entraîner des pertes de données, car elle ne dispose pas de mécanisme de nouvelle tentative.
Les sept principaux modèles de communication englobent plusieurs sous-classes. Une sous-classe décrit la manière dont l'appareil doit utiliser le CCI pour gérer la gestion de l'appareil et des appels. Le tableau ci-dessous présente toutes les sous-classes possibles et le modèle de communication auquel elles appartiennent.
Tableau – Sous-classes du CDC

Sous-classe
Modèle de contrôle de ligne directe Modèle de contrôle abstrait

Modèle de communication
PSTN
PSTN

Example des appareils utilisant cette sous-classe
Périphériques modem directement contrôlés par l'hôte USB
Périphériques d'émulation série, périphériques modem contrôlés via un jeu de commandes série

20/174

Surview

Sous-classe

Modèle de communication

Example des appareils utilisant cette sous-classe

Modèle de contrôle téléphonique

PSTN

Modèle RNIS de contrôle multicanal

Modèle de contrôle CAPI RNIS

Modèle de contrôle ECM de réseau Ethernet

Réseau de distributeurs automatiques de billets

ATM

Modèle de contrôle

Modèle de commande de combiné sans fil

WMC

Gestion des périphériques WMC

Modèle de ligne mobile directe

WMC

OBEX

WMC

Modèle EEM d'émulation Ethernet

Modèle de contrôle du réseau

NCM

Appareils de téléphonie vocale
Adaptateurs de terminaux à débit de base, adaptateurs de terminaux à débit primaire, téléphones
Adaptateurs de terminaux à débit de base, adaptateurs de terminaux à débit primaire, téléphones, modems câble DOC-SIS, modems ADSL prenant en charge l'émulation PPPoE, adaptateurs Wi-Fi (famille IEEE 802.11), adaptateurs IEEE 802.3, modems ADSL
Équipement terminal mobile se connectant à des appareils sans fil
Équipements terminaux mobiles se connectant à des appareils sans fil Équipements terminaux mobiles se connectant à des appareils sans fil
Équipements terminaux mobiles se connectant à des appareils sans fil. Appareils utilisant des trames Ethernet comme couche de transport suivante. Non destinés aux appareils de routage et de connectivité Internet. Adaptateurs IEEE 802.3 transportant une bande passante de données haut débit sur le réseau.

Besoins en ressources de la classe CDC ACM du périphérique USB à partir du noyau

Chaque fois que vous ajoutez une instance de classe CDC ACM à une configuration USB via un appel à la fonction sl_usbd_cdc_acm_add_to_configuration() , les ressources suivantes seront allouées à partir du noyau.

Ressource
Interfaces Interfaces alternatives Points de terminaison Groupes d'interfaces

Quantité
2 2 3 1

Notez que ces nombres sont exprimés par configuration. Lors de la configuration des valeurs SL_USBD_INTERFACE_QUANTITY, SL_USBD_ALT_INTERFACE_QUANTITY, SL_USBD_INTERFACE_GROUP_QUANTITY et SL_USBD_DESCRIPTOR_QUANTITY, n'oubliez pas de prendre en compte le nombre de configurations auxquelles la classe sera ajoutée. Pour la valeur de configuration SL_USBD_OPEN_ENDPOINTS_QUANTITY, les points de terminaison étant ouverts uniquement lorsqu'une configuration est définie par l'hôte, il suffit de prendre en compte le nombre de points de terminaison nécessaires à une instance de classe.
Périphérique USB CDC ACM Sous-classe Overview

La classe de base CDC est composée d'une interface de classe de communication (CCI) et d'une interface de classe de données (DCI), qui sont décrites en détail dans USB Device CDC Base Class Overview Cette section décrit un CCI de type ACM. Il se compose d'un point de terminaison par défaut pour l'élément de gestion et d'un point de terminaison d'interruption pour l'élément de notification. Deux points de terminaison groupés sont utilisés pour acheminer des données non spécifiées via le DCI.
La sous-classe ACM est utilisée par deux types d'appareils de communication :
Périphériques prenant en charge les commandes AT (par exemple, les modems à bande vocale). Périphériques d'émulation série, également appelés périphériques de port COM virtuel.
Il existe plusieurs requêtes spécifiques à la sous-classe ACM. Elles permettent de contrôler et de configurer l'appareil. La liste complète et la description de toutes les requêtes ACM sont disponibles dans la spécification.

21/174

Surview Sous-classe pour les appareils PSTN, révision 1.2, 9 février 2007=, section 6.2.2.
Dans cette liste, la sous-classe Silicon Labs9 ACM prend en charge les éléments suivants :
Tableau – Requêtes ACM prises en charge par Silicon Labs

Description de la demande de sous-classe

DéfinirCommFeature ObtenirCommFeature EffacerCommFeature

L'hôte envoie cette requête pour contrôler les paramètres d'une fonctionnalité de communication donnée. Non utilisé pour l'émulation série.
L'hôte envoie cette requête pour obtenir les paramètres actuels d'une fonctionnalité de communication donnée. Non utilisé pour l'émulation série.
L'hôte envoie cette requête pour effacer les paramètres d'une fonctionnalité de communication donnée. Non utilisé pour l'émulation série.

Définir le codage de ligne

L'hôte envoie cette requête pour configurer les paramètres du périphérique ACM : débit en bauds, nombre de bits d'arrêt, type de parité et nombre de bits de données. Pour une émulation série, cette requête est envoyée automatiquement par un terminal série chaque fois que vous configurez les paramètres série d'un port COM virtuel ouvert.

Obtenir le codage de ligne

L'hôte envoie cette requête pour obtenir les paramètres ACM actuels (débit en bauds, bits d'arrêt, parité, bits de données). Pour une émulation série, les terminaux série envoient automatiquement cette requête lors de l'ouverture d'un port COM virtuel.

SetControlLineState : l'hôte envoie cette requête pour contrôler la porteuse des modems semi-duplex et indiquer si l'équipement terminal de traitement de données (ETTD) est prêt ou non. Dans le cas d'une émulation série, l'ETTD est un terminal série. Pour une émulation série, certains terminaux série permettent d'envoyer cette requête avec les contrôles définis.

SetBreak

L'hôte envoie cette requête pour générer une interruption de type RS-232. Pour une émulation série, certains terminaux série permettent d'envoyer cette requête.

La sous-classe ACM de Silicon Labs9 utilise le point de terminaison d'interruption IN pour informer l'hôte de l'état actuel de la ligne série.
l'état de la ligne est une image bitmap informant l'hôte sur :

Données rejetées en raison d'un dépassement Erreur de parité Erreur de cadrage État de la détection du signal en anneau État du mécanisme de détection de rupture État de la porteuse de transmission État de la détection de la porteuse du récepteur

L'implémentation de la sous-classe ACM de Silicon Labs9 est conforme à la spécification suivante :
Universal Serial Bus, Communications, Sous-classe pour les périphériques PSTN, révision 1.2, 9 février 2007.
Configuration de classe CDC ACM du périphérique USB

Cette section explique comment configurer la classe ACM (Communication Device Class, Abstract Control Model) du CDC. Il existe deux groupes de paramètres de configuration :
Configurations spécifiques à l'application de la classe CDC ACM du périphérique USB Configurations d'instance de classe CDC ACM du périphérique USB
Configurations spécifiques à l'application de la classe CDC ACM du périphérique USB

Classe de base CDC Sous-classe ACM
Classe de base du CDC

Pour utiliser le module de classe CDC du périphérique USB de Silicon Labs, vous devrez ajuster la configuration de compilation CDC #define-s en fonction des besoins de votre application. Ces paramètres sont regroupés dans l'en-tête sl_usbd_core_config.h. file dans la section CDC. Leur objectif est d'informer le module de périphérique USB du nombre d'objets CDC USB à allouer.

22/174

Surview

Le tableau ci-dessous décrit chaque champ de configuration disponible dans cette structure de configuration.
Tableau – Définition de la configuration CDC du périphérique USB

Nom de la configuration
SL_USBD_CDC_CL AS S_INSTANCE_QUANT ITÉ
SL_USBD_CDC_CONFIGURATION_QUANTI
TY
SL_USBD_CDC_DATA_INTERFACE_QUANTI
TY

Description
Nombre d'instances de classe que vous allouerez via un appel à la fonction
sl_usbd_cdc_acm_create_instance() .
Nombre de configurations. Les instances de classe ACM peuvent être ajoutées à une ou plusieurs configurations aaaa via sl_usbd_cdc_acm_add_to_configuration() .
Nombre total d'interfaces de données (DCI) pour toutes les fonctions CDC. Chaque fonction CDC ACM a ajouté 10 ...

Valeur par défaut
2
1
2

Sous-classe ACM
La sous-classe ACM possède une configuration de compilation indiquée dans le tableau ci-dessous.
Tableau – Définition de la configuration CDC ACM du périphérique USB

Nom de la configuration
SL_USBD_CDC_ACM_SUBCL ASS_I NSTANCE_QUANTITÉ

Description
Configure le nombre d'instances de sous-classes que vous allouerez via un appel à la
fonction sl_usbd_cdc_acm_create_instance() .

Valeur par défaut
2

Configurations d'instance de classe CDC ACM du périphérique USB

Cette section définit les configurations relatives aux instances de classe série CDC ACM. Création d'instance de classe, état de ligne, intervalle d'appel, capacités de gestion, p_acm_callbacks
Création d'instance de classe

Pour créer une instance de classe série CDC ACM, appelez la fonction T a sl_usbd_cdc_acm_create_instance() . Cette fonction t contient trois arguments de configuration, comme décrit ici.

intervalle_état_ligne
Il s'agit de l'intervalle (en millisecondes) pendant lequel votre instance de classe série CDC ACM signalera les notifications d'état de ligne à l'hôte T aa. Cette valeur doit être une puissance de deux (1, 2, 4, 8, 16, etc.).

capacités_de_gestion_des_appels
Bitmap des fonctionnalités de gestion des appels. Les valeurs possibles sont les suivantes :

Valeur (bit)
SL_USBD_ACM_SÉRIE_GESTION_APPEL_SÉRIE_DEV
SL_USBD_ACM_SÉRIE_APPEL_GESTION_DONNÉES_CCI _DCI

Description
L'appareil gère lui-même la gestion des appels. Il peut envoyer et recevoir des informations de gestion des appels via une interface de classe de données.

p_acm_callbacks

23/174

Surview

aa M aa p_acm_callbacks est un pointeur vers une structure de type sl_usbd_cdc_acm_callbacks_t. Son objectif est de fournir à la classe CDC AC un ensemble de fonctions de rappel à appeler lorsqu'un événement CDC ACM se produit. Toutes les fonctions de rappel ne sont pas obligatoires et un pointeur nul ( NULL ) peut être passé dans la variable de structure callbacks lorsque le rappel n'est pas nécessaire. Le tableau ci-dessous décrit chaque champ de configuration disponible dans cette structure.
Tableau – Structure de configuration sl_usbd_cdc_acm _callbacks_t

Champs

Description

.activer

Appelé lorsque l'instance de classe USB est activée

avec succès.

.désactiver

Appelé lorsque l'instance de classe USB est désactivée.

.line_control_changed Appelé lorsqu'un changement de contrôle de ligne est reçu.

line_coding_changed Appelé lorsqu'un changement de codage de ligne est reçu.

Signature de fonction
void app_usbd_cdc_acm_enable(uint8_t sous-classe_nbr);
void app_usbd_cdc_acm_disable(uint8_t sous-classe_nbr);
void app_usbd_cdc_acm_line_control_changed(uint8_t sous-classe_nbr, uint8_t événement, uint8_t événement_chngd); bool app_usbd_cdc_acm_line_coding_changed(uint8_t sous-classe_nbr, sous-classe_nbr, sl_usbd_cdc_acm_line_coding_t
*p_line_coding

Voir la section Enregistrement des rappels de notification d'événement pour les fonctions de rappel example.
Guide de programmation de la classe CDC ACM pour périphériques USB

Cette section explique comment utiliser la classe CDC (modèle de contrôle abstrait). Initialisation de la classe CDC ACM du périphérique USB. Ajout d'une instance de classe CDC ACM du périphérique USB. Communication via la classe CDC ACM.
Initialisation de la classe CDC ACM du périphérique USB

Pour ajouter la fonctionnalité de classe CDC ACM à votre appareil, vous devez d'abord initialiser la classe de base CDC et la sous-classe ACM en appelant les fonctions sl_usbd_cdc_init() et sl_usbd_cdc_acm_init(). L'exemple ci-dessous montre comment appeler sl_usbd_cdc_init() et sl_usbd_cdc_acm_init() avec les arguments par défaut.

Example – Initialisation de la classe CDC ACM

sl_status_t statut;
status = sl_usbd_cdc_init(); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}
status = sl_usbd_cdc_acm_init(); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}
Ajout d'une instance de classe CDC ACM de périphérique USB à votre périphérique
Pour ajouter la fonctionnalité de classe CDC ACM à votre appareil, vous devez créer une instance, puis l'ajouter aux configurations de votre appareil.
Création d'une instance de classe CDC ACM

24/174

Surview
Ajout de l'instance de classe CDC ACM aux configurations de votre appareil Enregistrement des rappels de notification d'événements
Création d'une instance de classe CDC ACM
aa M aaa Créez une instance de classe CDC AC en appelant la fonction sl_usbd_cdc_acm_create_instance(). L'exemple ci-dessous montre comment créer une instance de classe CDC AC à l'aide de sl_usbd_cdc_acm_create_instance().
Example – Création d'une fonction CDC ACM via sl_usbd_cdc_acm_create_instance()

uint8_t sous-classe_nbr; sl_status_t statut;
statut = sl_usbd_cdc_acm_create_instance(64u, SL_USBD_ACM_SERIAL_CALL_MGMT_DATA_CCI_DCI | SL_USBD_ACM_SERIAL_CALL_MGMT_DEV, NULL, &subclass_nbr);
if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}
Ajout de l'instance de classe CDC ACM aux configurations de votre appareil
Après avoir créé une instance de classe CDC ACM, vous pouvez l'ajouter à une configuration en appelant la fonction
sl_usbd_cdc_acm_ajouter_à_la_configuration() .
L'exemple ci-dessous montre comment appeler sl_usbd_cdc_acm_add_to_configuration().
Example – Appel à USBD ACM sl_usbd_cdc_acm_add_to_configuration()

sl_status_t statut;

statut = sl_usbd_cdc_acm_add_to_configuration(sous-classe_nbr,

(1)

config_nbr_fs);

(2)

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

aaa (1) Numéro de classe à ajouter à la configuration renvoyée par sl_usbd_cdc_acm_create_instance() . (2) Numéro de configuration (ici en l'ajoutant à une configuration Full-Speed).
Enregistrement des rappels de notification d'événement
La classe CDC ACM Serial peut notifier votre application de toute modification du contrôle de ligne ou du codage via des fonctions de rappel de notification. Une structure de fonctions de rappel peut être passée en argument lors de la création de l'instance ACM. Notez que ces rappels sont facultatifs. Par exempleample – CDC ACM Callbacks Registration illustre l'utilisation des fonctions d'enregistrement de rappel. Example – L'implémentation des rappels CDC ACM montre un example d'implémentation des fonctions de rappel.
Example – Enregistrement des rappels CDC ACM

25/174

Surview

uint8_t sous-classe_nbr; sl_status_t statut;
sl_usbd_cdc_acm_callbacks_t sli_usbd_cdc_acm_callbacks = { app_usbd_cdc_acm_connect, app_usbd_cdc_acm_disconnect, app_usbd_cdc_acm_line_control_changed, app_usbd_cdc_acm_line_coding_changed, };
statut = sl_usbd_cdc_acm_create_instance(64u, SL_USBD_ACM_SERIAL_CALL_MGMT_DATA_CCI_DCI | SL_USBD_ACM_SERIAL_CALL_MGMT_DEV, &sli_usbd_cdc_acm_callbacks, &subclass_nbr);
if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */ }
Example – Implémentation des rappels CDC ACM

booléen app_usbd_cdc_acm_line_coding_changed (uint8_t

sous-classe_nbr,

sl_usbd_cdc_acm_line_coding_t *p_line_coding)

{

uint32_t débit en bauds_nouveau;

uint8_t parité_nouvelle;

uint8_t stop_bits_nouveaux;

uint8_t data_bits_nouveaux;

/* TODO Appliquer le codage de nouvelle ligne.*/ baudrate_new = p_line_coding->BaudRate; parity_new = p_line_coding->Parity; stop_bits_new = p_line_coding->StopBits; data_bits_new = p_line_coding->DataBits;

retour (vrai);

(1)

}

void app_usbd_cdc_acm_line_control_changed (uint8_t subclass_nbr, uint8_t event, uint8_t event_changed)
{ bool rts_state; bool rts_state_changed; bool dtr_state; bool dtr_state_changed; bool brk_state; bool brk_state_changed;

/* TODO Appliquer le contrôle de nouvelle ligne. */ rts_state = ((event & SL_USBD_CDC_ACM_CTRL_RTS) ! 0) ? true : false; rts_state_changed = ((event_changed & SL_USBD_CDC_ACM_CTRL_RTS) ! 0) ? true : false; dtr_state = ((event & SL_USBD_CDC_ACM_CTRL_DTR) ! 0) ? true : false; dtr_state_changed = ((event_changed & SL_USBD_CDC_ACM_CTRL_DTR) ! 0) ? true : false; brk_state = ((event & SL_USBD_CDC_ACM_CTRL_BREAK) ! 0) ? true : false; brk_state_changed = ((event_changed & SL_USBD_CDC_ACM_CTRL_BREAK) ! 0) ? vrai : faux;
}

(1) Il est important de renvoyer la valeur « false » à cette fonction si l'application du codage de ligne a échoué. Sinon, renvoyer la valeur « true ».
Communiquer à l'aide de la classe CDC ACM
État de la série
Codage de ligne Contrôle de ligne

26/174

Surview

Communication d'instance de sous-classe d'état de ligne
État de la série
Codage de ligne
L'hôte USB contrôle le codage de ligne (débit en bauds, parité, etc.) du périphérique CDC ACM. Si nécessaire, l'application se charge de définir le codage de ligne. Deux fonctions permettent de récupérer et de définir le codage de ligne actuel, comme décrit dans le tableau ci-dessous.
Tableau – Fonctions de codage de ligne CDC ACM

Fonction
sl_usbd_cdc_acm_get_line _cod ing()
sl_usbd_cdc_acm_s e t_line _co d ing ()

Description
Votre application peut obtenir les paramètres de codage de ligne actuels définis soit à partir de l'hôte avec des requêtes SetLineCoding, soit avec la fonction sl_usbd_cdc_acm_set_line_coding() .
Votre application peut définir le codage des lignes. L'hôte peut récupérer ces paramètres via la requête GetLineCoding.

Contrôle de ligne
L'hôte USB contrôle le contrôle de ligne (broches RTS et DTR, signal de coupure, etc.) du dispositif CDC ACM. Si nécessaire, votre application est responsable de l'application des contrôles de ligne. Une fonction permet de récupérer et de définir les contrôles de ligne actuels, comme décrit dans le tableau ci-dessous.
Tableau – Fonctions de contrôle de ligne CDC ACM

Fonction
sl_usb d _cd c_acm_get_line _control_state()

Votre application peut obtenir l'état actuel de la ligne de contrôle défini par l'hôte avec la requête SetControlLineState.

État de la ligne
L'hôte USB récupère l'état de la ligne à intervalles réguliers. Votre application doit mettre à jour cet état à chaque modification. Si nécessaire, elle est responsable de sa définition. Deux fonctions permettent de récupérer et de définir les contrôles de ligne actuels, comme décrit dans le tableau ci-dessous.
Tableau – Fonctions d'état de ligne CDC ACM

Fonction
sl_usb d _cd c_acm_set _line _state _e ve nt()
sl_usbd_cdc_acm_clear_line _state _e ve nt()

Votre application peut définir n'importe quel événement d'état de ligne. Lors de la définition de l'état de ligne, une interruption IN est envoyée à l'hôte pour l'informer d'un changement d'état de la ligne série.
L'application peut effacer deux événements de l'état de la ligne : la porteuse en émission et la porteuse en réception. Tous les autres événements sont automatiquement effacés par la sous-classe d'émulation série ACM.

Communication d'instance de sous-classe

La sous-classe ACM de Silicon Labs offre les fonctions suivantes pour communiquer avec l'hôte. Pour plus de détails sur les paramètres functions9, consultez la référence des fonctions de la sous-classe ACM du CDC.

Nom de la fonction
sl_usb d _cd c_acm_ lecture () sl_usb d _cd c_acm_écriture ()

Opération
Reçoit des données de l'hôte via un point de terminaison sortant en masse. Cette fonction est bloquante. Envoie des données à l'hôte via un point de terminaison entrant en masse. Cette fonction est bloquante.

27/174

Surview

Tableau – Résumé de l'API de communication CDC ACM. Les fonctions sl_usbd_cdc_acm_read() et sl_usbd_cdc_acm_write() assurent une communication synchrone, ce qui signifie que le transfert est bloquant. Autrement dit, lors de l'appel de la fonction, l'application se bloque jusqu'à la fin du transfert, avec ou sans erreur. Un délai d'attente peut être spécifié pour éviter une attente interminable. L'exempleampci-dessous montre un exemple de lecture et d'écritureample qui reçoit des données de l'hôte à l'aide du point de terminaison OUT en masse et envoie des données à l'hôte à l'aide du point de terminaison IN en masse.
Liste – Lecture et écriture en série Example

__ALIGNÉ(4) uint8_t rx_buf[2];

__ALIGNÉ(4) uint8_t tx_buf[2];

uint32_t

xfer_len;

sl_status_t

statut;

statut = sl_usbd_cdc_acm_read(sous-classe_nbr,

(1)

rx_buf,

(2)

2u,

0u,

(3)

&xfer_len);

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

statut = sl_usbd_cdc_acm_write(sous-classe_nbr,

(1)

tx_buf,

(4)

2u,

0u,

(3)

&xfer_len);

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

T aaaaa M (1) Le numéro d'instance de classe créé avec sl_usbd_cdc_acm_create_instance() fournit une référence interne à la sous-classe AC pour acheminer le transfert vers le point de terminaison OUT ou IN approprié. (2) Votre application doit s'assurer que le tampon fourni à la fonction est suffisamment grand pour accueillir toutes les données. Sinon, des problèmes de synchronisation peuvent survenir. (3) Pour éviter une situation de blocage infini, spécifiez un délai d'attente exprimé en millisecondes. Une valeur de 809 fait attendre la tâche d'application indéfiniment. (4) L'application fournit le tampon de transmission initialisé.

28/174

Surview
Surview

Classe HID du périphérique USB

Périphérique USB HID Classe Overview Besoins en ressources de la classe HID du périphérique USB à partir de la configuration de la classe HID du périphérique USB principal Guide de programmation de la classe HID du périphérique USB Tâche de rapports d'entrée périodiques HID
Cette section décrit la classe Human Interface Device (HID) prise en charge par Silicon Labs USB Device.
La classe HID englobe les appareils utilisés par les humains pour contrôler les opérations informatiques, tels que les claviers, les souris, les dispositifs de pointage et les consoles de jeu.
La classe HID peut également être utilisée dans un périphérique composite contenant des commandes telles que des boutons, des interrupteurs et des curseurs. Par exempleampLes commandes de volume, de sourdine et de coupure du son d'un casque audio sont gérées par la fonction HID. La classe HID permet l'échange de données à toutes fins, en utilisant uniquement les transferts de contrôle et d'interruption.
La classe HID est l'une des classes USB les plus anciennes et les plus utilisées. Tous les principaux systèmes d'exploitation hôtes fournissent un pilote natif pour gérer les périphériques HID, ce qui explique pourquoi de nombreux périphériques spécifiques à chaque fabricant fonctionnent avec la classe HID. Cette classe inclut également divers types d'éléments de sortie tels que les LED, l'audio, le retour tactile, etc.
L'implémentation HID est conforme aux spécifications suivantes :
Définition de classe de périphérique pour périphériques d'interface utilisateur (HID), 27/6/01, version 1.11. Tableaux d'utilisation HID pour bus série universel, 28/10/2004, version 1.12.
Périphérique USB HID Classe Overview
Surview
Un périphérique HID est composé des points de terminaison suivants :
Une paire de points de terminaison de contrôle IN et OUT appelés point de terminaison par défaut Un point de terminaison d'interruption IN Un point de terminaison d'interruption OUT facultatif
Le tableau ci-dessous décrit l'utilisation des différents points de terminaison :
Tableau – Utilisation des points de terminaison de classe HID

Utilisation de la direction du point de terminaison

Contrôle IN
Contrôle
DEHORS
Interruption IN
Interrompre
DEHORS

Appareil vers hôte
Hôte à appareil
Appareil vers hôte
Hôte à appareil

Requêtes standard d'énumération, requêtes spécifiques à une classe et communication de données (entrée, rapports de fonctionnalités envoyés à l'hôte via la requête GET_REPORT). Requêtes standard d'énumération, requêtes spécifiques à une classe et communication de données (sortie, rapports de fonctionnalités reçus de l'hôte via la requête SET_REPORT). Communication de données (entrée et rapports de fonctionnalités).
Communication de données (rapports de sortie et de fonctionnalités).

Rapport

29/174

Surview

Un hôte et un périphérique HID échangent des données via des rapports. Un rapport contient des données formatées fournissant des informations sur les commandes et autres entités physiques du périphérique HID. Une commande est manipulable par l'utilisateur et contrôle un aspect du périphérique. Par exempleampUn contrôle peut être un bouton de souris ou de clavier, un interrupteur, etc. D'autres entités informent l'utilisateur de l'état de certaines fonctionnalités de l'appareil. Par exempleamples LED sur un clavier informent l'utilisateur que le verrouillage des majuscules est activé, que le pavé numérique est actif, etc.
Le format et l'utilisation des données d'un rapport sont compris par l'hôte grâce à l'analyse du contenu d'un descripteur de rapport. L'analyse du contenu est effectuée par un analyseur. Le descripteur de rapport décrit les données fournies par chaque commande d'un périphérique. Il est composé d'éléments d'information sur le périphérique, constitués d'un préfixe d'un octet et d'une longueur variable.
données. Pour plus de détails sur le format de l'élément, reportez-vous à
1.11=, section 5.6 et 6.2.2.
Il existe trois principaux types d’articles :
L'élément principal définit ou regroupe certains types de champs de données.
L'élément global décrit les caractéristiques des données d'un contrôle.
L'élément local décrit les caractéristiques des données d'un contrôle.
Chaque type d'élément est défini par des fonctions différentes. Une fonction d'élément peut également être appelée tagUne fonction d'élément peut être considérée comme un sous-élément appartenant à l'un des trois principaux types d'éléments. Le tableau ci-dessous en donne un aperçu.view des fonctions de chaque type d'élément. Pour une description complète des éléments de chaque catégorie, voir
Tableau – Description de la fonction de l'élément pour chaque type d'élément

Article Type d'article Fonction

Description

Entrée principale

Décrit les informations sur les données fournies par un ou plusieurs contrôles physiques.

Sortie principale Décrit les données envoyées à l'appareil.

Caractéristiques principales

Décrit les informations de configuration de l'appareil envoyées ou reçues par l'appareil qui influencent le comportement global de l'appareil ou de l'un de ses composants.

Éléments liés au groupe de collection principal (entrée, sortie ou fonctionnalité).

Fin principale de Ferme une collection. Collection

30/174

Surview

Article Type d'article Fonction

Description

Page d'utilisation globale

Identifie une fonction disponible dans l'appareil.

Logique globale Définit la limite inférieure des valeurs signalées en unités logiques. Minimum

Logique globale Définit la limite supérieure des valeurs signalées en unités logiques. Maximum

Physique global Définit la limite inférieure des valeurs rapportées en unités physiques, c'est-à-dire le minimum logique Minimum exprimé en unités physiques.

Physique global Définit la limite supérieure des valeurs rapportées en unités physiques, c'est-à-dire le maximum logique exprimé en unités physiques.

Unité mondiale

Indique l'exposant de l'unité en base 10. L'exposant varie de -8 à +7.

Exposant

Unité mondiale

Indique l'unité des valeurs indiquées. Par exemple, longueur, masse, température, etc.

Taille du rapport global

Indique la taille des champs du rapport en bits.

ID de rapport global Indique le préfixe ajouté à un rapport particulier.

Nombre de rapports mondiaux

Indique le nombre de champs de données pour un élément.

Poussée mondiale

Place une copie de la table d’état des éléments globaux sur la pile du processeur.

Pop mondiale

Remplace la table d'état des éléments par la dernière structure de la pile.

Utilisation locale

Représente un index désignant une utilisation spécifique dans une page d'utilisation. Il indique l'utilisation suggérée par le fournisseur pour un contrôle ou un groupe de contrôles spécifique. Une utilisation fournit au développeur d'applications des informations sur ce que mesure réellement un contrôle.

Utilisation locale

Définit l'utilisation de départ associée à un tableau ou à une bitmap.

Minimum

Utilisation locale

Définit l'utilisation finale associée à un tableau ou à une bitmap.

Maximum

Désignateur local : détermine la partie du corps utilisée pour un contrôle. L’index pointe vers un désignateur dans le champ physique.

Indice

descripteur.

Désignateur local Définit l'index du désignateur de départ associé à un tableau ou une bitmap. Minimum

Désignateur local Définit l'index du désignateur de fin associé à un tableau ou une image bitmap. Maximum

Index de chaîne local

Index de chaîne pour un descripteur de chaîne. Il permet d'associer une chaîne à un élément ou un contrôle particulier.

Chaîne locale

Spécifie le premier index de chaîne lors de l'affectation d'un groupe de chaînes séquentielles aux contrôles d'un tableau

Minimum ou bitmap.

Local Local

Chaîne maximale
Délimiteur

Spécifie le dernier index de chaîne lors de l'attribution d'un groupe de chaînes séquentielles à des contrôles dans un tableau ou une bitmap.
Définit le début ou la fin d'un ensemble d'éléments locaux.

Les données d'un contrôle doivent définir au moins les éléments suivants :
Entrée, sortie ou fonctionnalité Éléments principaux Utilisation Élément local Page d'utilisation Élément global Minimum logique Élément global Maximum logique Élément global Taille du rapport Élément global

31/174

Surview
Élément global du nombre de rapports. Le tableau ci-dessous présente la représentation du contenu d'un descripteur de rapport de souris du point de vue d'un analyseur HID hôte. La souris possède trois boutons (gauche, droite et molette). Le code présenté dans l'exempleampci-dessous se trouve une implémentation de code correspondant à cette représentation du descripteur de rapport de souris.
Figure – Contenu du descripteur de rapport d'un analyseur HID hôte View

(1) La fonction de l'élément Page d'utilisation spécifie la fonction générale de l'appareil. Dans cet exempleample, le dispositif HID appartient à un
contrôle de bureau générique.
(2) La collection Application regroupe les éléments principaux ayant un objectif commun et pouvant être familiers aux applications. Dans le diagramme, le groupe est composé de trois éléments principaux d'entrée. Pour cette collection, l'utilisation suggérée pour les contrôles est une souris, comme indiqué par l'élément Usage. (3) Les collections imbriquées peuvent être utilisées pour fournir plus de détails sur l'utilisation d'un contrôle ou d'un groupe de contrôles aux applications. Dans cet exempleampLe physique de collection, imbriqué dans l'application de collection, est composé des trois mêmes éléments d'entrée que l'application de collection. Le physique de collection est utilisé pour un ensemble d'éléments de données représentant des points de données collectés en un point géométrique. Dans l'exempleampL'utilisation suggérée est un pointeur, comme indiqué par l'élément « Utilisation ». Ici, l'utilisation du pointeur fait référence aux coordonnées de la position de la souris, et le logiciel système les traduira par le déplacement du curseur à l'écran. (4) Des pages d'utilisation imbriquées sont également possibles et fournissent plus de détails sur un aspect spécifique du fonctionnement général de l'appareil. Dans ce cas, deux éléments « Entrées » sont regroupés et correspondent aux boutons de la souris. L'un d'eux définit les trois boutons de la souris (droit, gauche et molette) en termes de nombre de champs de données (élément « Nombre de rapports »), de taille de champ de données (élément « Taille du rapport ») et de valeurs possibles pour chaque champ de données (éléments « Minimum et Maximum d'utilisation », « Minimum et Maximum logiques »). L'autre élément « Entrée » est une constante de 13 bits permettant d'aligner les données du rapport d'entrée sur une limite d'octet. Cet élément « Entrée » sert uniquement à des fins de remplissage. (5) Une autre page d'utilisation imbriquée, faisant référence à un contrôle de bureau générique, est définie pour les coordonnées de la position de la souris. Pour cette page d'utilisation, l'élément d'entrée décrit les champs de données correspondant aux axes x et y tels que spécifiés par les deux Utilisation
articles.
Après avoir analysé le contenu du descripteur de rapport de la souris précédente, l'analyseur HID de l'hôte est capable d'interpréter les données du rapport d'entrée envoyées par le périphérique via un transfert d'entrée d'interruption ou en réponse à une requête GET_REPORT. Les données du rapport d'entrée correspondant au descripteur de rapport de la souris sont présentées dans la figure – Contenu du descripteur de rapport d'un analyseur HID hôte. View is

32/174

Surview

Le tableau ci-dessous indique la taille totale des données du rapport. La taille totale des données est de 4 octets. Différents types de rapports peuvent être envoyés via le même terminal. Afin de les distinguer, un préfixe d'identifiant de rapport d'un octet est ajouté au rapport de données. Si un identifiant de rapport a été utilisé dans l'exempleampdu rapport de la souris, la taille totale des données du rapport serait de 5 octets.
Tableau – Rapport d'entrée envoyé à l'hôte et correspondant à l'état d'une souris à 3 boutons

Décalage de bits
0 1 2 3 16 24

Nombre de bits 1 1 1 13 8 8

Description Bouton 1 (bouton gauche). Bouton 2 (bouton droit). Bouton 3 (bouton molette). Non utilisé. Position sur l'axe X. Position sur l'axe Y.

Un descripteur physique indique la ou les parties du corps destinées à activer une ou plusieurs commandes. Une application peut utiliser cette information pour attribuer une fonctionnalité à la commande d'un appareil. Un descripteur physique est un descripteur optionnel propre à une classe, et la plupart des appareils n'ont que peu d'intérêt à l'utiliser. Voir
Besoins en ressources de classe HID du périphérique USB à partir du noyau

Chaque fois que vous ajoutez une instance de classe HID à une configuration USB via un appel à la fonction sl_usbd_hid_add_to_configuration() , les ressources suivantes seront allouées à partir du noyau.

Ressource
Interfaces Interfaces alternatives Points de terminaison Groupes d'interfaces

Quantité
1 1 1 (2 si le point de terminaison OUT d'interruption est activé) 0

Deux groupes de paramètres de configuration sont utilisés pour configurer la classe HID :
Configurations spécifiques à l'application de la classe HID du périphérique USB Configurations d'instance de classe HID du périphérique USB
Configurations spécifiques à l'application de la classe HID du périphérique USB

Pour utiliser le module de classe HID de périphérique USB de Silicon Labs, ajustez les définitions de configuration HID à la compilation en fonction des besoins de votre application. Elles sont regroupées dans l'en-tête sl_usbd_core_config.h. file Sous la section HID. Elles se divisent en deux sections : les configurations de quantité et les configurations de tâches HID. La configuration de quantité sert à informer le module de périphérique USB du nombre d'objets HID USB à allouer.
Le tableau ci-dessous décrit chaque configuration définie.
Tableau – Définitions de configuration HID du périphérique USB

33/174

Surview

Nom de la configuration
SL_USBD_HID_CL ASS_I NSTANCE_QUANTITÉ
SL_USBD_HID_CONFIG URATION_QUANTITÉ
SL_USBD_HID_REPORT_ID_QUANTITÉ
SL_USBD_HID_PUSH_P OP_ARTICLE_QUANTITÉ
SL_USBD_HID_TIMER_T DEMANDER_TAILLE_DE_LA_PILE
SL_USBD_HID_TIMER_T DEMANDER_PRIORITÉ

Description
Nombre d'instances de classe que vous allouerez via un appel à la fonction
sl_usbd_hid_créer_instance() .
Nombre de configurations. Les instances de classe HID peuvent être ajoutées à une ou plusieurs configurations AAA via la fonction sl_usbd_hid_add_to_configuration(). Configure le nombre total d'ID de rapport à allouer.
Configure le nombre total d'éléments Push/Pop à allouer.
La tâche de temporisation gère toutes les opérations HID basées sur la temporisation. Cette configuration permet de définir la taille de la pile (en nombre d'octets). La priorité de la tâche HID est une priorité CMSIS-RTOS2.

Valeur par défaut
2 1 2 0 2048
osPrioritéÉlevée

Configurations d'instances de classe HID de périphérique USB Sous-classe de création d'instances de classe
protocole code_pays
interval_in et interval_out p_hid_callback Descripteur de rapport de classe HID ExampCette section définit les configurations liées aux instances de classe HID.
Création d'instance de classe
La création d'une instance de classe HID s'effectue en appelant la fonction aaa sl_usbd_hid_create_instance(), qui prend en charge plusieurs arguments de configuration décrits ci-dessous.
sous-classe
Code de la sous-classe HID. Valeurs possibles :
SL_USBD_HID_SUBCL ASS_AUCUN SL_USBD_HID_SUBCL ASS_BOOT
Un périphérique HID utilisant la sous-classe de démarrage doit utiliser des formats de rapport standard. Pour plus d'informations sur les codes de sous-classe, consultez la section 4.2 de la révision 1.11 de la spécification HID.
protocole
Protocole utilisé par le périphérique HID. Valeurs possibles :
SL_USBD_HID_PROTOCOLE_AUCUN SL_USBD_HID_PROTOCOLE_KBD SL_USBD_HID_PROTOCOLE_SOURIS
Si votre fonction HID est une souris, le protocole doit être défini sur SL_USBD_HID_PROTOCOL_MOUSE. S'il s'agit d'un clavier, il doit être défini sur SL_USBD_HID_PROTOCOL_KBD. Sinon, le protocole doit être défini sur SL_USBD_HID_PROTOCOL_NONE. Pour plus d'informations sur les codes de sous-classe, consultez la section 4.3 de la révision 1.11 de la spécification HID.
code_pays
Identifiant du code pays. Valeurs possibles :
SL_USBD_HID_CODE_PAYS_NON_PRIS_EN_CHARGE

34/174

Surview
SL_USBD_HID_CODE_PAYS_ARABE SL_USBD_HID_CODE_PAYS_BELGE SL_USBD_HID_CODE_PAYS_CANADIEN_BILINGUE SL_USBD_HID_CODE_PAYS_CANADIEN_FRANÇAIS SL_USBD_HID_CODE_PAYS_RÉPUBLIQUE_TCHÈQUE SL_USBD_HID_CODE_PAYS_DANOIS SL_USBD_HID_CODE_PAYS_FINNOIS SL_USBD_HID_CODE_PAYS_FRANÇAIS SL_USBD_HID_CODE_PAYS_ALLEMAND SL_USBD_HID_CODE_PAYS_GREC SL_USBD_HID_CODE_PAYS_HÉBREU SL_USBD_HID_CODE_PAYS_HONGRIE SL_USBD_HID_CODE_PAYS_INTERNATIONAL SL_USBD_HID_CODE_PAYS_ITALIEN SL_USBD_HID_CODE_PAYS_JAPON_KATAKANA SL_USBD_HID_CODE_PAYS_CORÉEN SL_USBD_HID_CODE_PAYS_LATINE_AMÉRICAIN SL_USBD_HID_CODE_PAYS_PAYS-BAS_NÉERLANDAIS SL_USBD_HID_CODE_PAYS_NORVÉGIEN SL_USBD_HID_CODE_PAYS_PERSIEN_FARSI SL_USBD_HID_CODE_PAYS_POL AND SL_USBD_HID_CODE_PAYS_PORTUGAIS SL_USBD_HID_CODE_PAYS_RUSSIE SL_USBD_HID_CODE_PAYS_SLOVAQUIE SL_USBD_HID_CODE_PAYS_ESPAGNOL SL_USBD_HID_CODE_PAYS_SUÉDOIS SL_USBD_HID_CODE_PAYS_SUISSE_FRANÇAIS SL_USBD_HID_CODE_PAYS_SUISSE_ALLEMAND SL_USBD_HID_CODE_PAYS_SUISSE ET SL_USBD_HID_CODE_PAYS_TAIWAN SL_USBD_HID_CODE_PAYS_TURC_Q SL_USBD_HID_CODE_PAYS_UK SL_USBD_HID_CODE_PAYS_US SL_USBD_HID_CODE_PAYS_YUG OSL AVIA SL_USBD_HID_CODE_PAYS_TURC_F
Le code pays identifie le pays pour lequel le matériel est localisé. La plupart des matériels ne sont pas localisés ; par conséquent, cette valeur serait SL_USBD_HID_COUNTRY_CODE_NOT_SUPPORTED (0). Cependant, les claviers peuvent utiliser ce champ pour indiquer la langue des touches.
Pour plus d'informations sur les codes pays, voir la section 6.2.1 de la révision 1.11 de la spécification HID.
intervalle_entrée et intervalle_sortie
interval_in et interval_out représentent l'intervalle d'interrogation du point de terminaison d'interruption IN et du point de terminaison d'interruption OUT.
Ceci représente l'intervalle d'interrogation du point de terminaison, en millisecondes. La définition de cette valeur dépend de la fréquence à laquelle votre appareil est susceptible de générer un nouveau rapport pour l'hôte. Par exemple, si un rapport est généré toutes les 16 millisecondes, l'intervalle doit être de 16 millisecondes ou moins.
La valeur doit être une puissance de 2 (1, 2, 4, 8, 16, etc.).
une valeur interval_out est ignorée si ctrl_rd_en est défini sur true.
p_hid_callback
aaaa p_hid_callback est un pointeur vers une structure de type sl_usbd_hid_callbacks_t. Son objectif est de fournir à la classe HID un ensemble de fonctions de rappel à appeler lorsqu'un événement HID se produit.

35/174

Surview

Tous les rappels ne sont pas obligatoires et un pointeur nul (NULL) peut être passé dans la variable de structure des rappels lorsque le rappel n'est pas nécessaire. Le tableau ci-dessous décrit chaque champ de configuration disponible dans cette structure.
Tableau – Structure de configuration sl_usbd_hid_callbacks_t

Champs

Description

Signature de fonction

.activer .désactiver .get_report_desc
.get_phy_desc
.set_output_report .get_feature_report .set_feature_report

Appelé lorsque l'instance de classe USB est activée. Appelé lorsque l'instance de classe USB est désactivée.
Appelée lors de la création de l'instance HID pour transmettre votre descripteur de rapport. Pour chacune de vos fonctions HID, vous devez fournir un descripteur de rapport. Ce descripteur indique à l'hôte comment le rapport périodique envoyé par l'appareil doit être analysé. Écrire votre propre descripteur de rapport peut s'avérer complexe, c'est pourquoi des ressources sont disponibles pour vous aider. Il s'agit de la seule fonction de rappel obligatoire. Appelée lors de la création de l'instance HID pour transmettre votre descripteur physique. Ce descripteur fournit des informations sur la ou les parties spécifiques du corps humain qui activent une ou plusieurs commandes. Pour plus d'informations sur les descripteurs physiques, consultez la section 6.2.3 de la révision 1.11 de la spécification HID. Le descripteur physique est facultatif et généralement ignoré. Le tampon transmis ici peut être défini sur NULL et sa longueur sur 0. Appelée lorsque l'hôte définit un rapport comme décrit dans votre descripteur de rapport (lorsqu'il envoie un rapport).
Appelé lorsque l'hôte demande un rapport de fonctionnalité comme décrit dans votre descripteur de rapport.
Appelé lorsque l'hôte définit un rapport de fonctionnalités comme décrit dans votre descripteur de rapport.

void app_usbd_hid_enable(uint8_t numéro_de_classe); void app_usbd_hid_disable(uint8_t numéro_de_classe); void app_usbd_hid_get_report_desc(uint8_t numéro_de_classe, const uint8_t *p_report_ptr, uint16_tp_report_len);
void app_usbd_hid_get_phy_desc(uint8_t class_nbr, const uint8_t *p_report_ptr, uint16_tp_report_len);
void app_usbd_hid_set_output_report(uint8_t numéro_classe, uint8_t ID_rapport, uint8_t *p_report_buf, uint16_t longueur_rapport); void app_usbd_hid_get_feature_report(uint8_t numéro_classe, uint8_t ID_rapport, uint8_t *p_report_buf, uint16_t longueur_rapport); void app_usbd_hid_set_feature_report(uint8_t numéro_classe, uint8_t ID_rapport, uint8_t *p_report_buf, uint16_t longueur_rapport);

.get_protocol

Récupère le protocole actif actuel.

void app_usbd_hid_get_protocol(uint8_t numéro_de_classe, uint8_t *p_protocol);

.set_protocol

Définit le protocole actif actuel.

void app_usbd_hid_set_protocol(uint8_t class_nbr, uint8_t protocole);

Descripteur de rapport de classe HID Example

Les cours HID de Silicon Labsampl'application fournit un exampd'un descripteur de rapport pour une souris simple. L'exampLe texte ci-dessous montre un descripteur de rapport de souris.
Example – Descripteur de rapport de souris

statique uint8_t app_usbd_hid_report_desc[] = {

(1 2) (XNUMX)

SL_USBD_HID_PAGE_UTILISATION_GLOBALE + 1, SL_USBD_HID_PAGE_UTILISATION_COMMANDES_GÉNÉRIQUES_DU_BUREAU,

SL_USBD_HID_LOCAL_USAGE + 1, SL_USBD_HID_CA_MOUSE,

(3)

36/174

Surview

SL_USBD_HID_COLLECTION_PRINCIPALE +1, SL_USBD_HID_COLLECTION_APPLICATION,(4)

SL_USBD_HID_LOCAL_USAGE +1, SL_USBD_HID_CP_POINTER,(5)

SL_USBD_HID_COLLECTION_PRINCIPALE +1, SL_USBD_HID_COLLECTION_PHYSIQUE,(6)

SL_USBD_HID_PAGE_D'UTILISATION_GLOBALE +1, BOUTON_PAGE_D'UTILISATION_USBD_HID,(7)

SL_USBD_HID_UTILISATION_LOCALE_MIN +1,0 01,

SL_USBD_HID_UTILISATION_LOCALE_MAX +1,0 03,

SL_USBD_HID_GLOBAL_LOG_MIN +1,0 00,

SL_USBD_HID_GLOBAL_LOG_MAX +1,0 01,

SL_USBD_HID_COMPTE_DE_RAPPORT_GLOBAL +1,0 03,

SL_USBD_HID_GLOBAL_REPORT_SIZE +1,0 01,

SL_USBD_HID_ENTRÉE_PRINCIPALE +1, SL_USBD_HID_DONNÉES_PRINCIPALES |

SL_USBD_HID_VARIABLE_PRINCIPALE |

SL_USBD_HID_MAIN_ABSOLU,

SL_USBD_HID_COMPTE_DE_RAPPORT_GLOBAL +1,0 01,(8)

SL_USBD_HID_GLOBAL_REPORT_SIZE +1,0 0D,

SL_USBD_HID_ENTRÉE_PRINCIPALE +1, SL_USBD_HID_CONSTANTE_PRINCIPALE,(9)

SL_USBD_HID_PAGE_UTILISATION_GLOBALE +1, SL_USBD_HID_PAGE_UTILISATION_COMMANDES_GÉNÉRIQUES_DU_BUREAU,

SL_USBD_HID_UTILISATION_LOCALE +1, SL_USBD_HID_DV_X,

SL_USBD_HID_LOCAL_USAGE +1, SL_USBD_HID_DV_Y,

SL_USBD_HID_GLOBAL_LOG_MIN +1,0 81,

SL_USBD_HID_GLOBAL_LOG_MAX +1,0 7F,

SL_USBD_HID_GLOBAL_REPORT_SIZE +1,0 08,

SL_USBD_HID_COMPTE_DE_RAPPORT_GLOBAL +1,0 02,

SL_USBD_HID_ENTRÉE_PRINCIPALE +1, SL_USBD_HID_DONNÉES_PRINCIPALES |

SL_USBD_HID_VARIABLE_PRINCIPALE |

SL_USBD_HID_MAIN_RELATIVE,

SL_USBD_HID_MAIN_ENDCOLLECTION,(10)

SL_USBD_HID_MAIN_ENDCOLLECTION

(11)};

(1) Le tableau représentant un descripteur de rapport de souris est initialisé de telle sorte que chaque ligne corresponde à un élément court. Ce dernier est formé d'un préfixe d'un octet et d'une donnée d'un octet. Voir viewédité par un analyseur HID hôte dans la figure – Contenu du descripteur de rapport d'un analyseur HID hôte View.
(2) La page d’utilisation générique du bureau est utilisée.
(3) Dans la page d'utilisation générique du bureau, l'utilisation tag suggère que le groupe de commandes sert à contrôler une souris. Un ensemble de souris se compose généralement de deux axes (X et Y) et d'un, deux ou trois boutons.
(4) La collecte de souris est démarrée.
(5) Dans la collection de souris, une utilisation tag Cela suggère plus spécifiquement que les commandes de la souris appartiennent à la collection de pointeurs. Une collection de pointeurs est un ensemble d'axes générant une valeur pour diriger, indiquer ou orienter les intentions de l'utilisateur vers une application.
(6) La collection de pointeurs est démarrée.
(7) La page d'utilisation des boutons définit un élément d'entrée composé de trois champs de 1 bit. Chaque champ de 1 bit représente respectivement les boutons 1, 2 et 3 de la souris et peut renvoyer une valeur de 0 ou 1.
(8) L'élément d'entrée pour la page d'utilisation des boutons est complété par 13 autres bits.
(9) Une autre page d'utilisation générique du bureau est indiquée pour décrire la position de la souris avec les axes X et Y. L'élément d'entrée est composé de deux champs de 8 bits dont la valeur peut être comprise entre -127 et 127.
(10) La collection de pointeurs est fermée.
(11) La collection de souris est fermée.
Page HID d'USB.org

37/174

Surview
L'USB Implementers Forum (USB-IF) propose un outil appelé « HID Descriptor Tool » ainsi que d'autres informations sur le format de descripteur de rapport. Pour plus d'informations, consultez http://www.usb.org/developers/hidpage/.
Guide de programmation de classe HID pour périphériques USB
Cette section explique comment utiliser la classe HID. Initialisation de la classe HID du périphérique USB. Ajout d'une instance de classe HID du périphérique USB à votre périphérique. Communication via la classe HID du périphérique USB.
Initialisation de la classe HID du périphérique USB
Pour ajouter la fonctionnalité de classe HID à votre appareil, vous devez d'abord initialiser la classe en appelant la fonction sl_usbd_hid_init(). L'exampL'exemple ci-dessous montre comment appeler sl_usbd_hid_init() avec les arguments par défaut. Pour plus d'informations sur les arguments de configuration à transmettre à sl_usbd_hid_init(), consultez la section Configurations spécifiques aux applications de la classe HID du périphérique USB.
Example – Appel de sl_usbd_hid_init()
sl_status_t statut;
status = sl_usbd_hid_init(); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}
Ajout d'une instance de classe HID de périphérique USB à votre périphérique
Pour ajouter la fonctionnalité de classe HID à votre appareil, vous devez créer une instance, puis l'ajouter à la ou aux configurations de votre appareil.
Création d'une instance de classe HID
Créez une instance de classe HID en appelant la fonction sl_usbd_hid_create_instance() . L'exempleampL'exemple ci-dessous montre comment créer une fonction souris simple via sl_usbd_hid_create_instance() avec les arguments par défaut. Pour plus d'informations sur les arguments de configuration à transmettre à sl_usbd_hid_create_instance(), consultez la section Configurations des instances de classe HID de périphérique USB.
Example – Ajout d'une fonction souris via sl_usbd_hid_create_instance()

38/174

Surview
/* Constantes globales. */ static const uint8_t app_usbd_hid_mouse_report_desc[] = {
SL_USBD_HID_PAGE_UTILISATION_GLOBALE + 1, SL_USBD_HID_PAGE_UTILISATION_COMMANDES_BUREAU_GÉNÉRIQUES, SL_USBD_HID_UTILISATION_LOCALE + 1, SL_USBD_HID_CA_MOUSE, SL_USBD_HID_COLLECTION_PRINCIPALE + 1, SL_USBD_HID_APPLICATION_COLLECTION, SL_USBD_HID_UTILISATION_LOCALE + 1, SL_USBD_HID_CP_POINTER, SL_USBD_HID_COLLECTION_PRINCIPALE + 1, SL_USBD_HID_COLLECTION_PHYSIQUE, SL_USBD_HID_PAGE_UTILISATION_GLOBALE + 1, SL_USBD_HID_PAGE_UTILISATION_BOUTON, SL_USBD_HID_UTILISATION_LOCALE_MIN + 1, 0 01, SL_USBD_HID_LOCAL_USAGE_MAX + 1, 0 03, SL_USBD_HID_GLOBAL_LOG_MIN + 1, 0 00, SL_USBD_HID_GLOBAL_LOG_MAX + 1, 0 01, SL_USBD_HID_GLOBAL_REPORT_COUNT + 1, 0 03, SL_USBD_HID_GLOBAL_REPORT_SIZE + 1, 0 01, SL_USBD_HID_MAIN_INPUT + 1, SL_USBD_HID_MAIN_DATA | SL_USBD_HID_MAIN_VARIABLE | SL_USBD_HID_PRINCIPAL_ABSOLU, SL_USBD_HID_COMPTE_RAPPORT_GLOBAL_+ 1, 0 01, SL_USBD_HID_TAILLE_RAPPORT_GLOBAL_+ 1, 0 0D, SL_USBD_HID_ENTRÉE_PRINCIPALE_+ 1, SL_USBD_HID_CONSTANTE_PRINCIPALE_, SL_USBD_HID_PAGE_UTILISATION_GLOBALE_+ 1, SL_USBD_HID_PAGE_UTILISATION_COMMANDES_GÉNÉRIQUES_DU_BUREAU, SL_USBD_HID_UTILISATION_LOCALE_+ 1, SL_USBD_HID_DV_X, SL_USBD_HID_UTILISATION_LOCALE_+ 1, SL_USBD_HID_DV_Y, SL_USBD_HID_LOG_GLOBAL_MIN + 1, 0 81, SL_USBD_HID_GLOBAL_LOG_MAX + 1, 0 7F, SL_USBD_HID_GLOBAL_REPORT_SIZE + 1, 0 08, SL_USBD_HID_GLOBAL_REPORT_COUNT + 1, 0 02, SL_USBD_HID_MAIN_INPUT + 1, SL_USBD_HID_MAIN_DATA | SL_USBD_HID_MAIN_VARIABLE | SL_USBD_HID_MAIN_RELATIVE, SL_USBD_HID_MAIN_ENDCOLLECTION, SL_USBD_HID_MAIN_ENDCOLLECTION };
/* Variables locales.*/ uint8_t class_nbr; sl_status_t status;
sl_usbd_hid_callbacks_t app_usbd_hid_callbacks = { NULL, NULL, app_usbd_hid_obtenir_desc_rapport, NULL, NULL, NULL, NULL, NULL, NULL };
void app_usbd_hid_get_report_desc(uint8_t numéro_de_classe, const uint8_t **p_report_ptr, uint16_t *p_report_len)
{ (void)class_nbr;
*p_report_ptr = app_usbd_hid_mouse_report_desc; *p_report_len = sizeof(app_usbd_hid_mouse_report_desc); }
statut = sl_usbd_hid_create_instance(SL_USBD_HID_SOUS-CLASSE_BOOT, SL_USBD_HID_PROTOCOLE_SOURIS, SL_USBD_HID_CODE_PAYS_NON_PRIS_EN_CHARGE, Ex_USBD_HID_Mouse_ReportDesc, sizeof(Ex_USBD_HID_Mouse_ReportDesc), 2u, 2u, true, &app_usbd_hid_callbacks, &class_nbr);
Copyright © 2025 Laboratoires de silicium. Tous droits réservés.

39/174

Surview
/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */}
Ajout de l'instance de classe HID aux configurations de votre appareil Après avoir créé une instance de classe HID, vous pouvez l'ajouter à une configuration en appelant la fonction
sl_usbd_hid_ajouter_à_la_configuration() .
L'exampci-dessous montre comment appeler sl_usbd_hid_add_to_configuration() .
Example – Appel de sl_usbd_hid_add_to_configuration()

sl_status_t statut;

sl_usbd_hid_ajouter_à_la_configuration(numéro_de_classe,

(1)

config_nbr_fs); (2)

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

(1) Numéro de classe à ajouter à la configuration renvoyée par sl_usbd_hid_create_instance(). (2) Numéro de configuration (ici en l'ajoutant à une configuration Full-Speed).
Communication à l'aide de la classe HID du périphérique USB
Communication d'instance de classe Communication synchrone Communication d'instance de classe La classe HID offre les fonctions suivantes pour communiquer avec l'hôte.
Tableau – Résumé de l'API de communication HID

Nom de la fonction
sl_usb d _hid _re ad _sy nc() sl_usb d _hid _write _sy nc()

Opération : Reçoit des données de l’hôte via le point de terminaison d’interruption OUT. Cette fonction est bloquante. Envoie des données à l’hôte via le point de terminaison d’interruption IN. Cette fonction est bloquante.

Communication synchrone : la communication synchrone signifie que le transfert est bloquant. Lors de l'appel de la fonction, l'application se bloque jusqu'à la fin du transfert, avec ou sans erreur. Un délai d'attente peut être spécifié pour éviter une attente interminable. L'exempleampLe schéma ci-dessous montre une lecture et une écriture qui reçoivent des données de l'hôte à l'aide du point de terminaison OUT d'interruption et envoient des données à l'hôte à l'aide du point de terminaison IN d'interruption.
Example – Lecture et écriture HID synchrones

__ALIGNÉ(4) uint8_t rx_buf[2];

__ALIGNÉ(4) uint8_t tx_buf[2];

uint32_t

xfer_len;

sl_status_t

statut;

statut = sl_usbd_hid_read_sync(class_nbr,

(1)

(void *)rx_buf,

(2)

2u,

0u,

(3)

&xfer_len);

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

40/174

Surview
status =sl_usbd_hid_read_sync(class_nbr,(1)(void *)rx_buf,(2)2u,0u,(3)&xfer_len);if(status ! SL_STATUS_OK){/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */}
status =sl_usbd_hid_write_sync(class_nbr,(1)(void *)tx_buf,(4)2u,0u,(3)&xfer_len);if(status ! SL_STATUS_OK){/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */}
(1) Le numéro d'instance de classe créé à partir de sl_usbd_hid_create_instance() fournit une référence interne à la classe HID pour acheminer le transfert vers le point de terminaison OUT ou IN approprié.
(2) L'application doit s'assurer que le tampon fourni à la fonction est suffisamment grand pour contenir toutes les données. Dans le cas contraire, des problèmes de synchronisation pourraient survenir. En interne, la lecture s'effectue soit avec le point de contrôle, soit avec le point d'interruption, selon l'indicateur de lecture de contrôle défini lors de l'appel de sl_usbd_hid_create_instance().
(3) Pour éviter un blocage infini, un délai d'attente exprimé en millisecondes peut être spécifié. Une valeur de 809 entraîne une attente indéfinie de la tâche applicative.
(4) L'application fournit le tampon de transmission initialisé.
Tâche de rapports d'entrée périodiques HID
Pour économiser la bande passante, l'hôte peut désactiver les rapports d'un point de terminaison d'entrée d'interruption en limitant leur fréquence. Pour ce faire, l'hôte doit envoyer la requête SET_IDLE. La classe HID implémentée par Silicon Labs contient une tâche interne respectant la limitation de fréquence des rapports, applicable à un ou plusieurs rapports d'entrée. La figure « Tâche de rapports d'entrée périodiques » illustre le fonctionnement de ces tâches.
Figure – Tâche de rapports d'entrée périodiques

(1) L'appareil reçoit une requête SET_IDLE. Cette requête spécifie une durée d'inactivité pour un identifiant de rapport donné. Pour plus d'informations sur la requête SET_IDLE, voir
(2) Une structure d'ID de rapport (allouée lors de la phase d'initialisation de la classe HID) est mise à jour avec la durée d'inactivité. Un compteur de durée d'inactivité est initialisé avec cette valeur. Cette structure est insérée à la fin d'une liste chaînée contenant les structures d'ID de rapports d'entrée. La durée d'inactivité est exprimée en 4 ms, ce qui donne une plage de 4 à 1 020 ms.

41/174

Surview
Si la durée d'inactivité est inférieure à l'intervalle d'interrogation du point de terminaison d'interruption IN, les rapports sont générés à l'intervalle d'interrogation.
(3) Toutes les 4 ms, la tâche de rapport d'entrée périodique parcourt la liste des identifiants de rapports d'entrée. Pour chaque identifiant, la tâche effectue l'une des deux opérations possibles. La durée de la période de la tâche correspond à l'unité de 4 ms utilisée pour la durée d'inactivité. Si aucune requête SET_IDLE n'a été envoyée par l'hôte, la liste des identifiants de rapports d'entrée est vide et la tâche n'a rien à traiter. La tâche traite uniquement les identifiants de rapport différents de 0 et dont la durée d'inactivité est supérieure à 0.
(4) Pour un ID de rapport d'entrée donné, la tâche vérifie si la durée d'inactivité est écoulée. Si elle n'est pas écoulée, le compteur est décrémenté et aucun rapport d'entrée n'est envoyé à l'hôte.
(5) Si la durée d'inactivité est écoulée (c'est-à-dire que le compteur de durée d'inactivité a atteint zéro), un rapport d'entrée est envoyé à l'hôte en appelant la fonction sl_usbd_hid_write_sync() via le point de terminaison d'interruption IN.
(6) Les données de rapport d'entrée envoyées par la tâche proviennent d'un tampon interne alloué à chaque rapport d'entrée décrit dans le descripteur de rapport. Une tâche applicative peut appeler la fonction sl_usbd_hid_write_sync() pour envoyer un rapport d'entrée. Après l'envoi des données, sl_usbd_hid_write_sync() met à jour le tampon interne associé à un identifiant de rapport d'entrée avec les données récemment envoyées. Ensuite, la tâche de rapports d'entrée périodiques envoie toujours les mêmes données après chaque période d'inactivité et jusqu'à ce que la tâche applicative mette à jour les données du tampon interne. Un mécanisme de verrouillage empêche la corruption des identifiants de rapport d'entrée en cas de modification au moment précis de la transmission par la tâche de rapports d'entrée périodiques.

42/174

Surview
Surview
Classe MSC pour périphériques USB
Périphérique USB MSC Class Overview Besoins en ressources de la classe MSC du périphérique USB à partir du noyau Configuration de la classe MSC du périphérique USB Guide de programmation de la classe MSC du périphérique USB Pilotes de stockage de la classe MSC du périphérique USB
Cette section décrit la classe de périphériques de stockage de masse (MSC) prise en charge par Silicon Labs USB Device. MSC est un protocole permettant le transfert d'informations entre un périphérique USB et un hôte. Les informations transférées sont tout ce qui peut être stocké électroniquement, comme des programmes exécutables, du code source, des documents, des images, des données de configuration ou d'autres données textuelles ou numériques. Le périphérique USB apparaît comme un support de stockage externe pour l'hôte, permettant le transfert de données. files par glisser-déposer.
A file système définit comment le fileLes données sont organisées dans le support de stockage. La spécification de la classe de stockage de masse USB n'exige aucune spécification particulière. file Système utilisable sur des périphériques conformes. Il offre une interface simple pour lire et écrire des secteurs de données à l'aide du jeu de commandes transparent SCSI (Small Computer System Interface). Ainsi, les systèmes d'exploitation peuvent traiter la clé USB comme un disque dur et la formater avec n'importe quel format. file système qu'ils aiment.
La classe de périphérique de stockage de masse USB prend en charge deux protocoles de transport, comme suit :
Transport en vrac uniquement (BOT) Contrôle/Transport en vrac/Interruption (CBI) (utilisé uniquement pour les lecteurs de disquettes)
La classe de périphérique de stockage de masse implémente le jeu de commandes transparent SCSI en utilisant uniquement le protocole BOT, ce qui signifie que seuls des points de terminaison groupés seront utilisés pour transmettre les données et les informations d'état. L'implémentation MSC prend en charge plusieurs unités logiques.
L'implémentation du MSC est conforme aux spécifications suivantes :
Spécification de la classe de stockage de masse du bus série universelview, Révision 1.3 5 septembre 2008. Classe de stockage de masse Universal Serial Bus Bulk-Only Transport, Révision 1.0 31 septembre 1999.
Périphérique USB MSC aCl ss terminéview
Points de terminaison du protocole Demandes de classe Small Computer System Interface (SCSI)
Protocole
Dans cette section, nous aborderons le protocole Bulk-Only Transport (BOT) de la classe de stockage de masse. Ce protocole comporte troistagen:
Le transport de commandes Le transport de données Le transport d'état
Les commandes de stockage de masse sont envoyées par l'hôte via une structure appelée « Command Block Wrapper » (CBW). Pour les commandes nécessitant un transport de données,tage, l'hôte tentera d'envoyer ou de recevoir le nombre exact d'octets du périphérique, comme spécifié par les champs de longueur et d'indicateur du CBW. Une fois le transport de données terminé,tage, l'hôte tente de recevoir un wrapper d'état de commande (CSW) du périphérique qui détaille l'état de la commande ainsi que tout résidu de données (si

43/174

Surview
tout). Pour les commandes qui n'incluent pas de transport de données stage, l'hôte tente de recevoir le CSW immédiatement après l'envoi du CBW. Le protocole est détaillé dans la figure – Protocole MSC.
Figure – Protocole MSC

Endpoints
Côté appareil, conformément à la spécification BOT, le MSC est composé des points de terminaison suivants : une paire de points de terminaison d'entrée et de sortie de contrôle, appelés points de terminaison par défaut, et une paire de points de terminaison d'entrée et de sortie en masse.
Le tableau ci-dessous indique les différentes utilisations des points de terminaison.
Tableau – Utilisation des points de terminaison MSC

Point final
Contrôle ENTRÉE Contrôle SORTIE Vrac ENTRÉE Vrac SORTIE

Direction
Appareil vers hôte Hôte vers appareil Appareil vers hôte Hôte vers appareil

Usage
Énumération et demandes spécifiques à la classe MSC Énumération et demandes spécifiques à la classe MSC Envoyer CSW et données Recevoir CBW et données

Demandes de cours
Il existe deux requêtes de contrôle définies pour le protocole MSC BOT. Ces requêtes et leurs descriptions sont détaillées dans le tableau ci-dessous.

Tableau – Demandes de classes de stockage de masse

Demandes de cours
Réinitialisation du stockage de masse en vrac uniquement

Description
Cette requête permet de réinitialiser le périphérique de stockage de masse et son interface associée. Elle prépare le périphérique à recevoir le bloc de commande suivant.

44/174

Surview

Demandes de cours

Description

Obtenir le maximum Cette requête est utilisée pour renvoyer le numéro d'unité logique (LUN) le plus élevé pris en charge par le périphérique. Par exempleample, un

LUN

Un périphérique avec LUN 0 et LUN 1 renverra une valeur de 1. Un périphérique avec une seule unité logique renverra 0 ou bloquera le

demande. La valeur maximale pouvant être renvoyée est de 15.

Interface SCSI pour petits systèmes informatiques

Au niveau de l'interface de programmation, le périphérique MSC implémente l'un des protocoles de communication standard pour supports de stockage, tels que SCSI et SFF-8020i (ATAPI). L'interface de programmation spécifie le protocole implémenté et permet au système d'exploitation hôte de charger le pilote de périphérique approprié pour communiquer avec le périphérique de stockage USB. SCSI est le protocole le plus couramment utilisé avec les périphériques de stockage USB MSC. Nous fournissons une implémentation de la sous-classe SCSI MSC, prête à l'emploi pour les utilisateurs de notre GSDK.
SCSI est un ensemble de normes pour la gestion des communications entre ordinateurs et périphériques. Ces normes incluent des commandes, des protocoles, des interfaces électriques et optiques. Les périphériques de stockage utilisant d'autres interfaces matérielles, comme l'USB, utilisent des commandes SCSI pour obtenir des informations sur le périphérique/l'hôte, contrôler son fonctionnement et transférer des blocs de données sur le support de stockage.
Les commandes SCSI couvrent une vaste gamme de types et de fonctions de périphériques ; chaque périphérique nécessite donc un sous-ensemble de ces commandes. En général, les commandes suivantes sont nécessaires aux communications de base :
ENQUÊTE LECTURE CAPACITÉ (10) LECTURE (10) DEMANDE TEST DE DÉTECTION UNITÉ PRÊTE ÉCRITURE (10)
Besoins en ressources de la classe MSC pour les périphériques USB du noyau

Chaque fois que vous ajoutez une instance de classe MSC à une configuration USB via la fonction sl_usbd_msc_add_to_configuration(), les ressources suivantes seront allouées à partir du noyau.

Ressource
Interfaces Interfaces alternatives Points de terminaison Groupes d'interfaces

Quantité
1 1 2 0

Deux groupes de paramètres de configuration sont utilisés pour configurer la classe MSC :
Configurations spécifiques à l'application de la classe MSC du périphérique USB Configuration de l'unité logique de la classe MSC du périphérique USB
Configurations spécifiques à l'application de la classe MSC du périphérique USB

Configurations de compilation de classe Création d'instance de classe

45/174

Surview

Configurations de compilation de classe
La classe MSC et la sous-classe SCSI du périphérique USB Silicon Labs sont configurables au moment de la compilation via #defines situées dans le fichier sl_usbd_core_config.h file.
Tableau – Constantes de configuration génériques

Nom de la configuration

Description

SL_USBD_MSC_CLASS_INST Nombre d'instances de classe que vous allouerez via un appel à la fonction

ANCE_QUANTITÉ

sl_usbd_msc_scsi_create_instance() .

SL_USBD_MSC_CONFIGURA Numéro de configuration à laquelle une instance de classe peut être ajoutée via un appel à la

TION_QUANTITÉ

fonction sl_usbd_msc_scsi_add_to_configuration() .

SL_USBD_MSC_LUN_QUANT Nombre d'unités logiques par instance de classe que vous ajouterez via un appel à la

ITÉ

fonction sl_usbd_msc_scsi_lun_add() .

SL_USBD_MSC_SCSI_64_BIT Active ou désactive la prise en charge de l'adresse de bloc logique (LBA) de 64 bits.
_LBA_FR

SL_USBD_MSC_DATA_BUFF Taille du tampon de données par instance de classe en octets ER_SIZE

Valeur par défaut
2
1
2
0
512

Création d'instance de classe
La création d'une instance de classe SCSI MSC pour périphérique USB s'effectue en appelant la fonction sl_usbd_msc_scsi_create_instance(). Cette fonction prend un argument de configuration, décrit ci-dessous.
p_scsi_callbacks
p_scsi_callbacks est un pointeur vers une structure de configuration de type sl_usbd_msc_scsi_callbacks_t. En plus des fonctions de rappel courantes de la classe de périphérique USB (connect/disconnect), il fournit à la classe MSC un ensemble de fonctions de rappel facultatives appelées lorsqu'un événement se produit sur l'unité logique. Un pointeur nul (NULL) peut être passé à cet argument si aucun rappel n'est nécessaire.
Le tableau ci-dessous décrit chaque champ de configuration disponible dans cette structure de configuration.
Tableau – Structure de configuration sl_usbd_msc_scsi_callbacks_t

Champs

Description

.activer

Appelé lorsque l'instance de classe USB est activée avec succès.

.disable Appelé lorsque l'instance de classe USB est désactivée.

.host_eject Fonction appelée lorsqu'une unité logique est éjectée de l'hôte.

Signature de fonction
void app_usbd_msc_scsi_enable(uint8_t class_nbr);
void app_usbd_msc_scsi_disable(uint8_t class_nbr); void app_usbd_msc_scsi_host_eject(uint8_t class_nbr, uint8_t lu_nbr);

Configuration de l'unité logique de classe MSC du périphérique USB

L'ajout d'une unité logique à une instance de classe MSC s'effectue en appelant la fonction sl_usbd_msc_lun_add(). Cette fonction prend un argument de configuration, décrit ci-dessous.

p_lu_info

p_lu_info est un pointeur vers une structure de type sl_usbd_msc_scsi_lun_info_t. Son objectif est de fournir des informations sur l'unité logique à la classe MSC.
Le tableau ci-dessous décrit chaque champ de configuration disponible dans cette structure de configuration.

Tableau – Structure de configuration sl_usbd_msc_scsi_lun_info_t

46/174

Surview

Champ

Description

Champ
.scsi_lun_api_p tr

Description
Pointeur vers l'API du pilote multimédia qui gère cette unité logique. Pour plus d'informations sur les pilotes de stockage, consultez la section Pilotes de stockage de classe MSC pour périphériques USB.

.vend ou r_id _ p tr
.product_id_ptr
.p ro d uct_re v isi on_level .est_en_lecture_uniquement

Pointeur vers une chaîne contenant l'identification du fournisseur de l'unité logique. Longueur maximale : 8 caractères. Pointeur vers une chaîne contenant l'identification du produit de l'unité logique. Longueur maximale : 16 caractères. Niveau de révision du produit.
Drapeau qui indique si l'unité logique doit être considérée comme en lecture seule à partir du point de view de l'hôte ( vrai ) ou non ( faux ).

Guide de programmation de classe MSC pour périphériques USB

Cette section explique comment utiliser la classe MSC.
Initialisation de la classe MSC du périphérique USB Ajout d'une instance de classe SCSI MSC du périphérique USB à votre périphérique Gestion des unités logiques de classe MSC du périphérique USB
Initialisation de la classe MSC du périphérique USB

Pour ajouter la fonctionnalité de classe SCSI MSC à votre périphérique, initialisez d'abord la classe de base MSC et la sous-classe SCSI en appelant la fonction sl_usbd_msc_init() et sl_usbd_msc_scsi_init() .
L'exampci-dessous montre comment appeler sl_usbd_msc_init() et sl_usbd_msc_scsi_init() .

Example – Appel de sl_usbd_msc_init() et sl_usbd_msc_scsi_init()

sl_status_t statut;
status = sl_usbd_msc_init(); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}
status = sl_usbd_msc_scsi_init(); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}
Ajout d'une instance de classe SCSI MSC de périphérique USB à votre périphérique
Pour ajouter la fonctionnalité de classe SCSI MSC à votre périphérique, créez d'abord une instance, puis ajoutez-la à sa configuration. Vous devez ajouter au moins une unité logique à votre instance.
Création d'une instance de classe SCSI MSC
Créez une instance de classe MSC SCSI en appelant la fonction sl_usbd_msc_scsi_create_instance() .
L'exampL'exemple ci-dessous montre comment appeler sl_usbd_msc_scsi_create_instance() avec les arguments par défaut. Pour plus d'informations sur les arguments de configuration à transmettre à sl_usbd_msc_scsi_create_instance(), consultez la section Configurations spécifiques à l'application de la classe MSC des périphériques USB.
Example – Appel de sl_usbd_ msc_scsi_create_instance()

47/174

Surview

uint8_t class_nbr; sl_status_t statut;
sl_usbd_msc_scsi_callbacks_t app_usbd_msc_scsi_callbacks = { .enable = NULL, .disable = NULL, .host_eject = NULL };
statut = sl_usbd_msc_scsi_create_instance(&app_usbd_msc_scsi_callbacks,0 &class_nbr);
if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */ }
Ajout de l'instance de classe MSC aux configurations de votre appareil
Après avoir créé une instance de classe MSC, vous pouvez l'ajouter à une configuration en appelant la fonction
sl_usbd_msc_ajouter_à_la_configuration() .
L'exampci-dessous montre comment appeler sl_usbd_msc_scsi_add_to_configuration() en utilisant les arguments par défaut.
Example – Appel de sl_usbd_ msc_scsi_add_to_configuration()

sl_status_t statut;

statut = sl_usbd_msc_scsi_add_to_configuration(class_nbr,

(1)

config_nbr_fs);

(2)

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

(1) Numéro de classe à ajouter à la configuration renvoyée par sl_usbd_msc_scsi_create_instance() . (32) Numéro de configuration (ici en l'ajoutant à une configuration Full-Speed).
Gestion des unités logiques de classe MSC des périphériques USB
Ajout d'une unité logique Connexion/déconnexion d'un support de stockage
Ajout d'une unité logique
Lors de l'ajout d'une unité logique à votre instance de classe SCSI MSC, celle-ci doit être liée à un support de stockage (disque RAM, carte SD, mémoire flash, etc.). La classe MSC utilise un pilote de stockage pour communiquer avec le support. Ce pilote devra être fourni lors de l'ajout de l'unité logique.
L'exampci-dessous montre comment ajouter une unité logique via sl_usbd_msc_scsi_lun_add() .
Example – Ajout d'une unité logique via sl_usbd_msc_scsi_lun_add()

48/174

Surview

sl_usbd_msc_scsi_lun_t *lu_object_ptr = NULL;

sl_usbd_msc_scsi_lun_info_t lu_info;

sl_status_t

statut;

lu_info.sl_usbd_msc_scsi_lun_api_t = &app_usbd_scsi_storage_block_device_api;

lu_info.vendor_id_ptr

= « Silicon Labs » ;

lu_info.product_id_ptr

= « périphérique de blocage example”;

lu_info.product_revision_level = 0x1000u;

lu_info.est_en_lecture_seule

= faux;

statut = sl_usbd_msc_scsi_lun_add(numéro_de_classe, &lu_info, &lu_object_ptr);
if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */ }

Attacher/détacher un support de stockage
Après l'ajout de l'unité logique, un support de stockage doit être connecté pour être accessible côté hôte. La classe MSC propose deux fonctions pour contrôler l'association du support de stockage à l'unité logique : sl_usbd_msc_scsi_lun_attach() et sl_usbd_msc_scsi_lun_detach(). Ces fonctions permettent d'émuler la suppression d'un périphérique de stockage afin de pouvoir y accéder à nouveau depuis l'application embarquée si nécessaire.
L'exampci-dessous montre comment utiliser la fonction sl_usbd_msc_scsi_lun_attach() et sl_usbd_msc_scsi_lun_detach() .
Example – Attacher/Détacher le média

sl_status_t statut;

status = sl_usbd_msc_scsi_lun_attach(lu_object_ptr); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}

…

(1)

statut = sl_usbd_msc_scsi_lun_detach(lu_object_ptr); si (statut ! SL_STATUS_OK) {
/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}

…

(2)

statut = sl_usbd_msc_scsi_lun_attach(lu_object_ptr) si (statut ! SL_STATUS_OK) {
/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */
}

…

(3)

(1) A partir de ce moment, si le dispositif MSC est connecté à un hôte, le support de stockage est accessible.
(2) Si le périphérique MSC est connecté à un hôte, le support apparaîtra désormais comme indisponible. Les opérations sur le support pourront alors être effectuées depuis l'application embarquée.
(3) Encore une fois, si le périphérique MSC est connecté à l'hôte, le support de stockage apparaîtra comme connecté.
Pilotes de stockage de classe MSC pour périphériques USB
La classe MSC « Périphérique USB » nécessite un pilote de stockage pour communiquer avec un support de stockage. Pour le moment, Silicon Labs ne propose pas de pilote.

49/174

Surview
L'IA du pilote TPY est définie par le typedef sl_usbd_msc_scsi_lun_api_t. Notre variable sl_usbd_msc_scsi_lun_api_t doit être incluse dans votre variable sl_usbd_msc_scsi_lun_info_t, argument utilisé lorsque vous ajoutez une unité logique l avec sl_usbd_msc_scsi_lun_add(). Consultez la section API SCSI MSC des périphériques USB pour plus de détails sur les structures. L'implémentation du pilote de stockage peut être aussi simple qu'un tableau de secteurs en RAM. La taille typique des secteurs (c'est-à-dire la taille des blocs) est de 512 pour les périphériques de stockage de masse et de 2048 pour les CD-ROM.

50/174

Surview
Surview
Classe de fournisseur de périphériques USB
Classe de fournisseur de périphérique USB terminéeview Besoins en ressources de la classe Fournisseur de périphériques USB (configuration de base) Guide de programmation de la classe Fournisseur de périphériques USB La classe Fournisseur vous permet de créer des périphériques spécifiques à un fournisseur, capables d'implémenter un protocole propriétaire. Elle s'appuie sur deux points de terminaison groupés pour transférer des données entre l'hôte et le périphérique. Les transferts groupés sont pratiques pour transférer de grandes quantités de données non structurées et assurent un échange fiable de données grâce à un mécanisme de détection d'erreurs et de nouvelle tentative. Outre les points de terminaison groupés, la classe Fournisseur peut également utiliser deux points de terminaison d'interruption optionnels. Tout système d'exploitation (SE) peut fonctionner avec la classe Fournisseur, à condition qu'il dispose d'un pilote pour la gérer. Selon le SE, le pilote peut être natif ou spécifique au fournisseur. Par exemple, sous Microsoft Windows®, votre application interagit avec le pilote WinUSB fourni par Microsoft pour communiquer avec le périphérique fournisseur.
Classe de fournisseur de périphérique USB terminéeview
Figure – Architecture générale entre l'hôte Windows et la classe fournisseur montre l'architecture générale entre l'hôte et le périphérique utilisant la classe fournisseur. Dans cet exempleample, le système d'exploitation hôte est MS Windows.
Figure – Architecture générale entre l'hôte MS Windows et la classe fournisseur

Côté MS Windows, l'application communique avec le périphérique du fournisseur via une bibliothèque USB. Les bibliothèques, comme libusb, proposent une API permettant de gérer un périphérique et ses canaux associés, et de communiquer avec lui via des points de terminaison de contrôle, de traitement en masse et d'interruption.
Côté appareil, la classe Vendor est composée des points de terminaison suivants :
Une paire de points de terminaison d'entrée et de sortie de contrôle, appelés points de terminaison par défaut. Une paire de points de terminaison d'entrée et de sortie en masse.

51/174

Surview

Une paire de points d'entrée et de sortie d'interruption. Cette paire est facultative. Le tableau ci-dessous indique l'utilisation des différents points d'entrée :
Tableau – Utilisation des points de terminaison de classe de fournisseur

Direction du point final

Contrôle IN
Contrôle
DEHORS
En vrac

Appareil vers hôte
>Hôte à périphérique
Appareil vers hôte

Bulk OUT
Interruption IN
Interrompre
DEHORS

Hôte à appareil
Appareil vers hôte
Hôte à appareil

Usage
Demandes standard d'énumération et demandes spécifiques aux fournisseurs.
Demandes standard d'énumération et demandes spécifiques aux fournisseurs.
Communication de données brutes. Les données peuvent être structurées selon un protocole propriétaire.
Communication de données brutes. Les données peuvent être structurées selon un protocole propriétaire.
Communication ou notification de données brutes. Les données peuvent être structurées selon un protocole propriétaire. Communication ou notification de données brutes. Les données peuvent être structurées selon un protocole propriétaire.

L'application du périphérique peut utiliser des points de terminaison en masse et par interruption pour envoyer et recevoir des données vers ou depuis l'hôte. Elle ne peut utiliser que le point de terminaison par défaut pour décoder les requêtes spécifiques au fournisseur envoyées par l'hôte. Les requêtes standard sont gérées en interne par la couche principale de Silicon Labs USB Device.
Besoins en ressources de la classe du fournisseur de périphériques USB à partir du noyau

Chaque fois que vous ajoutez une instance de classe de fournisseur à une configuration via la fonction sl_usbd_vendor_add_to_configuration(), les ressources suivantes seront allouées à partir du noyau.

Ressource
Interfaces Interfaces alternatives Points de terminaison Groupes d'interfaces

Quantité
1 1 2 (4 si vous avez activé les points de terminaison d'interruption) 0

Deux groupes de paramètres de configuration sont utilisés pour configurer la classe Vendor :
Configurations spécifiques à l'application de la classe de fournisseur de périphériques USB Configurations d'instance de classe de fournisseur de périphériques USB
Configurations spécifiques à l'application de la classe du fournisseur de périphériques USB
Pour utiliser le module de classe Fournisseur de périphériques USB de Silicon Labs, ajustez les définitions de configuration de compilation du fournisseur selon les besoins de votre application. Elles sont regroupées dans l'en-tête sl_usbd_core_config.h. file Dans la section Fournisseur. Les configurations de quantité permettent d'informer le module de périphérique USB du nombre d'objets Fournisseur USB à allouer.
Le tableau ci-dessous décrit chaque configuration définie.

52/174

Surview

Tableau – Définition de la configuration du fournisseur de périphériques USB

Nom de la configuration

Description

Valeur par défaut

SL_USBD_VENDOR_CLASS_INSTANCE_QUANTITY Nombre d'instances de classe que vous allouerez via un appel à la fonction 2 sl_usbd_vendor_create_instance() .

SL_USBD_VENDOR_CONFIGURATION_QUANTITY Nombre de configurations. Les instances de classe fournisseur peuvent être ajoutées à une ou plusieurs configurations via un appel à la fonction sl_usbd_vendor_add_to_configuration().

Configurations d'instance de classe de fournisseur de périphérique USB

Cette section définit les configurations liées aux instances de classe Vendor.
Création d'instance de classe intr_en intervalle p_vendor_callbacks
Création d'instance de classe

La création d'une instance de classe Vendor se fait en appelant la fonction sl_usbd_vendor_create_instance(), qui prend trois arguments de configuration décrits ci-dessous.

intr_fr
Booléen indiquant si une paire de points de terminaison d'interruption doit être ajoutée ou non.

Valeur
vrai faux

Description
Une paire de points de terminaison d'entrée/sortie sera ajoutée et mise à disposition de l'application embarquée. Aucun point de terminaison d'interruption ne sera ajouté. Seule une paire de points de terminaison d'entrée/sortie en masse sera disponible.

intervalle
Si vous définissez intr_en sur true, vous pouvez spécifier l'intervalle d'interrogation des points d'interruption (en millisecondes). Si vous définissez intr_en sur false, vous pouvez définir l'intervalle sur 0, car il sera ignoré par la classe.
p_vendor_callbacks
p_vendor_callbacks est un pointeur vers une variable de structure de fonction de rappel, que vous pouvez spécifier pour gérer les requêtes de contrôle spécifiques à la classe. Si vous n'utilisez pas de requêtes spécifiques à la classe ou si vous devez activer/désactiver les notifications, vous pouvez définir cette variable à NULL.
L'exampLe tableau ci-dessous fournit la signature attendue de votre gestionnaire de requêtes spécifiques à la classe.
Example – Signature de la fonction de requête spécifique à la classe

void app_usbd_vendor_req_handle(uint8_t

numéro_de_classe, (1)

const sl_usbd_setup_req_t *p_setup_req); (2)

sl_usbd_vendor_callbacks_t app_usbd_vendor_callback_functions =
{
.enable = NULL, .disable = NULL, .setup_req = app_usbd_vendor_req_handle,
};

(1) Numéro d'instance de classe de fournisseur.

53/174

Surview

(2) Pointeur vers une demande de configuration reçue de l'hôte.
Guide de programmation de classe de fournisseur de périphériques USB
Cette section explique comment utiliser la classe Vendor. Initialisation de la classe Vendor de périphérique USB. Ajout d'une instance de classe Vendor de périphérique USB à votre périphérique. Communication via la classe Vendor de périphérique USB.
Initialisation de la classe du fournisseur de périphériques USB
Pour ajouter une fonctionnalité de classe fournisseur à votre appareil, initialisez d'abord la classe en appelant la fonction USBD_Vendor_Init(). L'exempleampci-dessous montre comment appeler sl_usbd_vendor_init() .
Example – Appel de sl_usbd_vendor_init()

sl_status_t statut;
status = sl_usbd_vendor_init(); if (status ! SL_STATUS_OK) { /* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */ }
Ajout d'une instance de classe de fournisseur de périphérique USB à votre périphérique
Pour ajouter une fonctionnalité de classe fournisseur à votre appareil, vous devez d'abord créer une instance, puis l'ajouter à la ou aux configurations de votre appareil.
Création d'une instance de classe fournisseur Ajout de l'instance de classe fournisseur aux configurations de votre appareil
Création d'une instance de classe fournisseur
Créez une instance de classe Vendor en appelant la fonction sl_usbd_vendor_create_instance(). L'exampL'exemple ci-dessous montre comment appeler sl_usbd_vendor_create_instance() avec les arguments par défaut. Pour plus d'informations sur les arguments de configuration à transmettre à sl_usbd_vendor_create_instance(), consultez la section Configurations des instances de classe fournisseur de périphériques USB.
Example – Appel de sl_usbd_vendor_create_instance()

uint8_t class_nbr; sl_status_t statut;

statut = sl_usbd_vendor_create_instance(faux,

(1)

0u,

(2)

fonctions de rappel du fournisseur app_usbd, (3)

&class_nbr);

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

(1) Aucun point de terminaison d'interruption avec cette instance de classe. (2) L'intervalle est ignoré car les points de terminaison d'interruption sont désactivés.

54/174

Surview

(3) Fonction de rappel intégrée à votre application qui gère les requêtes de classe spécifiques au fournisseur. Consultez la section « Communication via la classe fournisseur de périphériques USB » pour plus d'informations. Ajout de l'instance de classe fournisseur aux configurations de votre périphérique : après avoir créé une instance de classe fournisseur, vous pouvez l'ajouter à une configuration en appelant la fonction USBD_Vendor_ConfigAdd(). L'exempleampci-dessous montre comment appeler sl_usbd_vendor_add_to_configuration() en utilisant les arguments par défaut.
Example – Appel de sl_usbd_vendor_add_to_configuration()

sl_status_t statut;

statut = sl_usbd_vendor_add_to_configuration(class_nbr,

(1)

config_nbr_fs);

(2)

si (statut ! SL_STATUS_OK) {

/* Une erreur s'est produite. La gestion des erreurs doit être ajoutée ici. */

}

(1) Numéro de classe à ajouter à la configuration renvoyée par sl_usbd_vendor_create_instance() . (2) Numéro de configuration (ici en l'ajoutant à une configuration Full-Speed).
Communication à l'aide de la classe de fournisseur de périphériques USB
Communication synchrone générale Communication asynchrone Demande de fournisseur Général La classe Vendor offre les fonctions suivantes pour communiquer avec l'hôte. Pour plus de détails sur les paramètres de la fonction, voir API du fournisseur de périphériques USB.
Tableau – Résumé de l'API de communication avec les fournisseurs

Nom de la fonction
sl_usb d _v e nd o r_ re ad _b ulk_sy nc() sl_usb d _v e nd o r_write _b ulk_sy nc() sl_usb d _v e nd o r_ re ad _b ulk_asy nc() sl_usb d _v e nd o r_ write _b ulk_asy nc() sl_usb d _v e nd o r_ re ad _interrup t_sy nc() sl_usb d _v e nd o r_ write _interrup t_sy nc() sl_usb d _v e nd o r_ re ad _interrup t_asy nc
()
sl_usb d _vend o r_write _interrup t_asy nc
()

Operation Receives data from host through bulk OUT endpoint. This function is blocking. Sends data to host through bulk IN endpoint. This function is blocking. Receives data from host through bulk OUT endpoint. This function is non-blocking. Sends data to host through bulk IN endpoint. This function is non-blocking. Receives data from host through interrupt OUT endpoint. This function is blocking. Sends data to host through interrupt IN endpoint. This function is blocking. Receives data from host through interrupt OUT endpoint. This function is non-
blocage.
Sends data to host through interrupt IN endpoint. This function is non-blocking.

The vendor requests are also another way to communicate with the host. When managing vendor requests sent by the host, the application can receive or send data from or to the host using the control endpoint; you will need to provide an application callback passed as a parameter of sl_usbd_vendor_create_instance() . Synchronous Communication

55/174

Surview

Synchronous communication means that the transfer is blocking. When a function is called, the application blocks until the transfer completes with or without an error. A timeout can be specified to avoid waiting forever. The example below shows a read and write that receives data from the host using the bulk OUT endpoint and sends data to the host using the bulk IN endpoint.
Example – Synchronous Bulk Read and Write

__ALIGNÉ(4) uint8_t rx_buf[2];

__ALIGNÉ(4) uint8_t tx_buf[2];

uint32_t

xfer_len;

sl_status_t

statut;

status = sl_usbd_vendor_read_bulk_sync(class_nbr,

(1)

(void *)&rx_buf[0],

(2)

2u,

0u,

(3)

&xfer_len);

si (statut ! SL_STATUS_OK) {

/* $$$$ Gère l'erreur. */

}

status = sl_usbd_vendor_write_bulk_sync( class_nbr,

(1)

(void *)&tx_buf[0],

(4)

2u,

0u,

(3)

false,

(5)

&xfer_len);

si (statut ! SL_STATUS_OK) {

/* $$$$ Gère l'erreur. */

}

(1) The class instance number created with sl_usbd_vendor_create_instance() provides an internal reference to the Vendor class to route the transfer to the proper bulk OUT or IN endpoint.
(2) The application must ensure that the buffer provided to the function is large enough to accommodate all the data. Otherwise, synchronization issues might happen.
(3) In order to avoid an infinite blocking situation, a timeout expressed in milliseconds can be specified. A value of 809 makes the application task wait forever.
(4) L'application fournit le tampon de transmission initialisé.
(5) If this flag is set to true , and the transfer length is multiple of the endpoint maximum packet size, the device stack will send a zero-length packet to the host to signal the end of the transfer.
The use of interrupt endpoint communication functions, sl_usbd_vendor_read_interrupt_sync() and sl_usbd_vendor_write_interrupt_sync() , is similar to bulk endpoint communication functions presented in Example – Synchronous Bulk Read and Write.
Communication asynchrone
Asynchronous communication means that the transfer is non-blocking. When a function is called, the application passes the transfer information to the device stack and does not block. Other application processing can be done while the transfer is in progress over the USB bus. Once the transfer has completed, a callback function is called by the device stack to inform the application about the transfer completion. The example below shows asynchronous read and write.
Example – Asynchronous Bulk Read and Write

56/174

Surview

void app_usbd_vendor_comm (uint8_t class_nbr)

{

__ALIGNÉ(4) uint8_t rx_buf[2];

__ALIGNÉ(4) uint8_t tx_buf[2];

sl_status_t

statut;

status = sl_usbd_vendor_read_bulk_async(class_nbr,

(void *)&rx_buf[0],

(2)

2u,

app_usbd_vendor_rx_completed,

NULL);

(4)

si (statut ! SL_STATUS_OK) {

/* $$$$ Gère l'erreur. */

}

status = sl_usbd_vendor_write_bulk_async(class_nbr,

(void *)&tx_buf[0],

(5)

2u,

app_usbd_vendor_tx_completed,

NULL

(4)

false);

(6)

si (statut ! SL_STATUS_OK) {

/* $$$$ Gère l'erreur. */

}

(1 3) (XNUMX)
(1 3) (XNUMX)

static void app_usbd_vendor_rx_completed(uint8_t class_nbr,

(3)

void *p_buf,

uint32_t buf_len,

uint32_t xfer_len,

void *p_callback_arg,

sl_status_t status)

{

si (statut ! SL_STATUS_OK) {

/* $$$$ Do some processing. */

} autre {

/* $$$$ Gère l'erreur. */

}

static void app_usbd_vendor_tx_completed(uint8_t class_nbr,

(3)

void *p_buf,

uint32_t buf_len,

uint32_t xfer_len,

void *p_callback_arg,

sl_status_t status)

{

si (statut ! SL_STATUS_OK) {

/* $$$$ Do some processing. */

} autre {

/* $$$$ Gère l'erreur. */

}

(1) The class instance number provides an internal reference to the Vendor class to route the transfer to the proper bulk OUT or IN endpoint. (2) The application must ensure that the buffer provided is large enough to accommodate all the data. Otherwise, there may be synchronization issues. (3) The application provides a callback function pointer passed as a parameter. Upon completion of the transfer, the device stack calls this callback function so that the application can finalize the transfer by analyzing the transfer result. For instance, on completion of a read operation, the application might perform processing on the received data. Upon write completion, the application can indicate if the write was successful and how many bytes were sent.

57/174

Surview
(4) An argument associated with the callback can be also passed. Then in the callback context, some private information can be retrieved. (5) The application provides the initialized transmit buffer. (6) If this flag is set to true , and the transfer length is a multiple of the endpoint maximum packet size, the device stack will send a zero-length packet to the host to signal the end of transfer. The use of interrupt endpoint communication functions, sl_usbd_vendor_read_interrupt_async() and sl_usbd_vendor_write_interrupt_async() , is similar to the bulk endpoint communication functions presented in Example Asynchronous Bulk Read and Write.
Vendor Request
The USB 2.0 specification defines three types of requests: standard, class, and vendor. All standard requests are handled directly by the core layer, while class requests are managed by the proper associated class. Vendor requests can be processed by the vendor class. To process vendor requests, you must provide an application callback as a parameter of sl_usbd_vendor_create_instance() . After a vendor request is received by the USB device, it must be decoded properly. The example below shows vendor request decoding. Certain requests may be required to receive from or send to the host during the data stage of a control transfer. If no data stage is present, you only have to decode the Setup packet. This example shows the three types of data stage management: no data, data OUT and data IN.
Example – Vendor Request Decoding

58/174

Surview

#define APP_VENDOR_REQ_NO_DATA

0x01u

#define APP_VENDOR_REQ_RECEIVE_DATA_FROM_HOST 0x02u

#define APP_VENDOR_REQ_SEND_DATA_TO_HOST 0x03u

#define APP_VENDOR_REQ_DATA_BUF_SIZE

50u

static uint8_t app_vendor_req_buf[APP_VENDOR_REQ_DATA_BUF_SIZE];

static bool app_usbd_vendor_req (uint8_t

class_nbr,

const sl_usbd_setup_req_t *p_setup_req)

(1)

{

bool valid;

sl_status_t statut;

uint16_t req_len;

uint32_t xfer_len;

(void)class_nbr;

switch(p_setup_req->bRequest) { case APP_VENDOR_REQ_NO_DATA: valid = true; break;

(2 3) (XNUMX)

case APP_VENDOR_REQ_RECEIVE_DATA_FROM_HOST:

(4)

req_len = p_setup_req->wLength;

if (req_len > APP_VENDOR_REQ_DATA_BUF_SIZE) {

// Not enough room to receive data.

return (false);

}

// Receive data via Control OUT EP. // Wait transfer completion forever. status = sl_usbd_core_read_control_sync((void *)&app_vendor_req_buf[0u],
req_len, 0u, &xfer_len); if (status ! SL_STATUS_OK) { valid = false; } else { valid = true; } break;

case APP_VENDOR_REQ_SEND_DATA_TO_HOST:

(5)

req_len = APP_VENDOR_REQ_DATA_BUF_SIZE;

// Fill buf with a pattern. Mem_Set((void *)&AppVendorReqBuf[0u],
'UN',
req_len);

// Send data via Control IN EP. // Wait transfer completion forever. status = sl_usbd_core_write_control_sync((void *)&app_vendor_req_buf[0u],
req_len, 0u, false, &xfer_len); if (status ! SL_STATUS_OK) { valid = DEF_FAIL; } else { valid = DEF_OK; } break;

défaut:

(6)

// Request is not supported.

59/174

Surview

valid =true;break;
case APP_VENDOR_REQ_RECEIVE_DATA_FROM_HOST:(4) req_len = p_setup_req->wLength;if(req_len > APP_VENDOR_REQ_DATA_BUF_SIZE){// Not enough room to receive data.return(false);}// Receive data via Control OUT EP.// Wait transfer completion forever. status =sl_usbd_core_read_control_sync((void *)&app_vendor_req_buf[0u],
req_len,0u,&xfer_len);if(status ! SL_STATUS_OK){ valid =false;}else{ valid =true;}break;
case APP_VENDOR_REQ_SEND_DATA_TO_HOST:(5) req_len = APP_VENDOR_REQ_DATA_BUF_SIZE;// Fill buf with a pattern.Mem_Set((void *)&AppVendorReqBuf[0u],’A’,
req_len);// Send data via Control IN EP.// Wait transfer completion forever. status =sl_usbd_core_write_control_sync((void *)&app_vendor_req_buf[0u],
req_len,0u,false,&xfer_len);if(status ! SL_STATUS_OK){ valid = DEF_FAIL;}else{ valid = DEF_OK;}break;
default:(6)// Request is not supported. valid = DEF_FAIL;break;}return(valid);}

(1) The core will pass the Setup packet content to your application. The structure sl_usbd_setup_req_t contains the same fields as defined by the USB 2.0 specification (refer to section “9.3 USB Device Requests” of the specification for more details):

typedef struct {

uint8_t bmRequestType; /* Characteristics of request.

uint8_t bRequest; /* Specific request.

uint16_t wValue; /* Varies according to request.

uint16_t wIndex; /* Varies according to request; typically used as index.*/

uint16_t wLength; /* Transfer length if data stage présent.

} sl_usbd_setup_req_t;

(2) Determine the request. You may use a switch statement if you are using different requests. In this example, there are three different requests corresponding to the three types of the data stage: APP_VENDOR_REQ_NO_DATA, APP_VENDOR_REQ_RECEIVE_DATA_FROM_HOST, and APP_VENDOR_REQ_SEND_DATA_TO_HOST.
(3) If no data stage is present, you only need to decode the other fields. The presence of a data stage or not is indicated by the field wLength being non-null or null.
(4) If the host sends data to the device, you must call the function sl_usbd_core_read_control_sync() . The buffer provided should be able to contain up to wLength bytes. If any error occurs, return false to the core that will stall the status stage of the control transfer, indicating to the host that the request cannot be processed. true is returned in case of success.
(5) If the host receives data from the device, you must call the function sl_usbd_core_write_control_sync() . If any error occurs, return false to the core that will stall the status stage of the control transfer, indicating to the host that the request cannot be processed. true is returned in case of success.
(6) In this example, all requests not recognized are marked by returning false to the core. This one will stall the data or status stage of the control transfer indicating to the host that the request is not supported.
The host sends vendor requests through a host vendor application. USb libraries, such as libusb, can be used to help you develop your custom host vendor application.

60/174

Documentation de l'API
Documentation de l'API
Documentation de l'API
Liste des modules
USB Device API USB Device ACM API USB Device CDC API USB Device Core API USB Device HID API USB Device MSC API USB Device MSC SCSI API USB Device Vendor API

Description
USB Device API USB Device ACM API USB Device CDC API USB Device Core API USB Device HID API USB Device MSC API USB Device MSC SCSI API USB Device Vendor API

61/174

USB Device API
USB Device API
USB Device API
USB Device API.
Modules
USB Device ACM API USB Device CDC API USB Device Core API USB Device HID API USB Device MSC API USB Device MSC SCSI API USB Device Vendor API

62/174

USB Device ACM API

USB Device CDC ACM API.
Modules
a sl_usbd_cdc_ cm_line_coding_t sl_usbd_cdc_acm_callbacks_t
Fonctions

sl_status_t sl_status_t
sl_status_t sl_status_t sl_status_t
sl_status_t
sl_status_t
sl_status_t
sl_status_t sl_status_t sl_status_t sl_status_t sl_status_t

a sl_usbd_cdc_ cm_init(void)
GLOBAL VARIABLES.
ssll__uussbbdd__ccddcc__aaccmm__ccraellabtaec_kins_stta*npc_ea(cumin_tc1a6l_lbtalicnkes_,sutaintte8__int t*eprv_saul,bucinlats1s6__nt bcra)ll_mgmt_capabilities,
Add a new instance of the CDC ACM serial emulation subclass.
a a a a sl_usbd_cdc_ cm_ dd_to_configur tion(uint8_t subcl ss_nbr, uint8_t config_nbr)
Add a CDC ACM subclass class instance into USB device configuration.
a a sl_usbd_cdc_ cm_is_en bled(uint8_t subclass_nbr, bool *p_enabled)
Get the CDC ACM serial emulation subclass enable state.
a a a sl_usbd_cdc_ cm_re d(uint8_t subcl ss_nbr, uint8_t *p_buf, uint32_t buf_len, uint16_t timeout, uint32_t
*p_xfer_len) Receive data on the CDC ACM serial emulation subclass.
a a a a sl_usbd_cdc_ cm_re d_ sync(uint8_t subcl ss_nbr, uint8_t *p_buf, uint32_t buf_len, a a a a sl_usbd_cdc_ sync_function_t sync_fnct, void *p_ sync_ rg)
Receive data on the CDC ACM serial emulation subclass asynchronously.
a a sl_usbd_cdc_ cm_write(uint8_t subcl ss_nbr, uint8_t *p_buf, uint32_t buf_len, uint16_t timeout, uint32_t
*p_xfer_len) Send data on the CDC ACM serial emulation subclass.
a a a sl_usbd_cdc_ cm_write_ sync(uint8_t subcl ss_nbr, uint8_t *p_buf, uint32_t buf_len, a a a a sl_usbd_cdc_ sync_function_t sync_fnct, void *p_ sync_ rg)
Send data on the CDC ACM serial emulation subclass asynchronously.
a a a sl_usbd_cdc_ cm_get_line_control_st te(uint8_t subcl ss_nbr, uint8_t *p_line_ctrl)
Return the state of control lines.
a a a sl_usbd_cdc_ cm_get_line_coding(uint8_t subcl ss_nbr, sl_usbd_cdc_ cm_line_coding_t *p_line_coding)
Get the current state of the line coding.
a a a sl_usbd_cdc_ cm_set_line_coding(uint8_t subcl ss_nbr, sl_usbd_cdc_ cm_line_coding_t *p_line_coding)
Set a new line coding.
a a a sl_usbd_cdc_ cm_set_line_st te_event(uint8_t subcl ss_nbr, uint8_t events)
Set a line state event(s).
a a a a sl_usbd_cdc_ cm_cle r_line_st te_event(uint8_t subcl ss_nbr, uint8_t events)
Clear a line state event(s).

63/174

USB Device ACM API
Macros
#define SL_USBD_CDC_ACM_NBR_NONE 255u
MODULE.
#define SL_USBD_CDC_ACM_PARITY_NONE 0u
PORT SETTINGS DEFINES.
#define SL_USBD_CDC_ACM_PARITY_ODD 1u #define SL_USBD_CDC_ACM_PARITY_EVEN 2u #define SL_USBD_CDC_ACM_PARITY_MARK 3u #define SL_USBD_CDC_ACM_PARITY_SPACE 4u #define SL_USBD_CDC_ACM_STOP_BIT_1 0u #define SL_USBD_CDC_ACM_STOP_BIT_1_5 1u #define SL_USBD_CDC_ACM_STOP_BIT_2 2u #define SL_USBD_CDC_ACM_CTRL_BREAK 0 01u
LINE EVENTS FLAGS DEFINES.
#define SL_USBD_CDC_ACM_CTRL_RTS 0 02u #define SL_USBD_CDC_ACM_CTRL_DTR 0 04u #define SL_USBD_CDC_ACM_STATE_DCD 0 01u #define SL_USBD_CDC_ACM_STATE_DSR 0 02u #define SL_USBD_CDC_ACM_STATE_BREAK 0 04u #define SL_USBD_CDC_ACM_STATE_RING 0 08u #define SL_USBD_CDC_ACM_STATE_FRAMING 0 10u #define SL_USBD_CDC_ACM_STATE_PARITY 0 20u #define SL_USBD_CDC_ACM_STATE_OVERUN 0 40u #define SL_USBD_CDC_ACM_CALL_MGMT_DEV 0 01u
CALL MANAGEMENT CAPABILITIES.
#define SL_USBD_CDC_ACM_CALL_MGMT_DATA_CCI_DCI 0 02u #define SL_USBD_CDC_ACM_CALL_MGMT_DATA_OVER_DCI 0 02u | 0 01u)
Function Documentation
sl_usbd_cdc_acm_init
sl_status_t sl_usbd_cdc_acm_init (void )
GLOBAL VARIABLES. Parameters
Copyright © 2025 Laboratoires de silicium. Tous droits réservés.

64/174

USB Device ACM API

Taper
vide

Direction N/A

Argument Name

MACROS GLOBAL CONSTANTS FUNCTION PROTOTYPES CDC ACM FUNCTIONS

Initialize the CDC ACM serial emulation subclass.
Retours

Returns SL_STATUS_OK on success or another SL_STATUS code on failure.

Description

sl_usbd_cdc_acm_create_instance

sl_status_t sl_usbd_cdc_acm_create_instance (uint16_t line_state_interval, uint16_t call_mgmt_capabilities, sl_usbd_cdc_acm_callbacks_t * p_acm_callbacks, uint8_t * p_subclass_nbr)

Add a new instance of the CDC ACM serial emulation subclass.
Paramètres

Taper
uint16_t
uint16_t

Direction Argument Name

Description

N / A

line_state_interval Line state notification interval in milliseconds (value must

be a power of 2).

N / A

call_mgmt_capabilities Call Management Capabilities bitmap. OR’ed of the

following flags:

SL_USBD_CDC_ACM_CALL_MGMT_DEV Device handles call management itself. SL_USBD_CDC_ACM_CALL_MGMT_DATA_CCI_DCI Device can send/receive call management information over a Data Class interface.

sl_usbd_cdc_acm_callbacks_t N/A
*

uint8_t *

N / A

p_acm_callbacks p_subclass_nbr

Optional pointers to callback functions to be called on various events.
Param to variable that will receive CDC ACM serial emulation subclass instance number.

Retours

Return SL_STATUS_OK on success or another SL_STATUS code on failure.

sl_usbd_cdc_acm_add_to_configuration

sl_status_t sl_usbd_cdc_acm_add_to_configuration (uint8_t subclass_nbr, uint8_t config_nbr)

Add a CDC ACM subclass class instance into USB device configuration.
Paramètres

Taper
uint8_t uint8_t

Direction N/A N/A

Argument Name
subclass_nbr config_nbr

Description CDC ACM serial emulation subclass instance number. Configuration index to add new test class interface to.

Retours

65/174

USB Device ACM API
Returns SL_STATUS_OK on success or another SL_STATUS code on failure.

sl_usbd_cdc_acm_is_enabled

sl_status_t sl_usbd_cdc_acm_is_enabled (uint8_t subclass_nbr, bool * p_enabled)

Get the CDC ACM serial emulation subclass enable state.
Paramètres

Taper

Direction

Argument Name

Description

uint8_t N/A

subclass_nbr CDC ACM serial emulation subclass instance number.

bool * N/A

p_enabled

Boolean to a variable that will receive enable status. The variable is set to true, CDC ACM serial emulation is enabled. The va

Documents / Ressources

SILICON LABS USB Device Stack [pdf] Manuel d'instructions
USB Device Stack, Device Stack, Stack

Références

Manuel d'utilisation

Manuel d'instructions de la pile de périphériques USB SILICON LABS

Pile de périphériques USB

Caractéristiques

Produit terminéview

Caractéristiques

Instructions d'utilisation du produit

Configuration du périphérique USB

Guide de programmation des périphériques USB

Classes de périphériques USB

Dépannage des périphériques USB

Hôte USB du système d'exploitation Microsoft Windows

FAQ

Q : Quels sont les ex courantsamples appareils que je peux construire en utilisant
cette pile USB ?

Q : Existe-t-il des exigences logicielles spécifiques pour utiliser ce produit ?
Pile de périphériques USB ?

Documents / Ressources

Références

Laisser un commentaire

Annuler la réponse

Pile de périphériques USB

Caractéristiques

Produit terminéview

Caractéristiques

Instructions d'utilisation du produit

Configuration du périphérique USB

Guide de programmation des périphériques USB

Classes de périphériques USB

Dépannage des périphériques USB

Hôte USB du système d'exploitation Microsoft Windows

FAQ

Q : Quels sont les ex courantsamples appareils que je peux construire en utilisant cette pile USB ?

Q : Existe-t-il des exigences logicielles spécifiques pour utiliser ce produit ? Pile de périphériques USB ?

Documents / Ressources

Références

Laisser un commentaire

Annuler la réponse

Q : Quels sont les ex courantsamples appareils que je peux construire en utilisant
cette pile USB ?

Q : Existe-t-il des exigences logicielles spécifiques pour utiliser ce produit ?
Pile de périphériques USB ?