Cette page a été traduite par l'API Cloud Translation.

Capteurs HAL 1.0

L'interface HAL des capteurs, déclarée dans sensors.h, représente l'interface entre le framework Android et le sur les logiciels spécifiques au matériel. Une implémentation HAL doit définir chaque fonction déclaré dans "Sensors.h". Les principales fonctions sont les suivantes:

get_sensors_list : renvoie la liste de tous les capteurs.
activate : démarre ou arrête un capteur.
batch : définit les paramètres d'un capteur, tels que la fréquence d'échantillonnage et la valeur maximale la latence des rapports.
setDelay : utilisé uniquement dans la version 1.0 de HAL. Définit la fréquence d'échantillonnage d'une un capteur donné.
flush : vide la file d'attente FIFO du capteur spécifié et signale un événement de vidage terminé une fois cette opération effectuée.
poll : renvoie les événements de capteur disponibles.

L'implémentation doit être thread-safe et permettre l'appel de ces fonctions à partir de différents threads.

L'interface définit également plusieurs types utilisés par ces fonctions. Les principaux types sont les suivants :

sensors_module_t
sensors_poll_device_t
sensor_t
sensors_event_t

En plus des sections ci-dessous, consultez sensors.h pour en savoir plus sur ces types.

get_sensors_list(list)

int (*get_sensors_list)(struct sensors_module_t* module, struct sensor_t
  const** list);

Fournit la liste des capteurs implémentés par le HAL. Consultez la section sensor_t pour en savoir plus sur la définition des capteurs.

L'ordre dans lequel les capteurs apparaissent dans la liste correspond à l'ordre dans lequel ils seront signalés aux applications. En général, les capteurs de base apparaissent en premier, suivis des capteurs composites.

Si plusieurs capteurs partagent le même type de capteur et la même propriété d'activation, le premier l'un des capteurs de la liste est le capteur par défaut. C'est celle renvoyée par getDefaultSensor(int sensorType, bool wakeUp).

Cette fonction renvoie le nombre de capteurs dans la liste.

activate(sensor, true/false)

int (*activate)(struct sensors_poll_device_t *dev, int sensor_handle, int
  enabled);

Active ou désactive un capteur.

sensor_handle est la poignée du capteur à activer/désactiver. Un capteur handle est défini par le champ handle de sa structure sensor_t.

enabled est défini sur 1 pour activer le capteur ou sur 0 pour le désactiver.

Les capteurs ponctuels se désactivent automatiquement lors de la réception d'un événement. et ils doivent tout de même accepter la désactivation en appelant activate(..., enabled=0).

Les capteurs non réveillés n'empêchent jamais le SoC de passer en mode suspension. Autrement dit, le HAL ne doit pas maintenir un wakelock partiel au nom des applications.

Les capteurs de veille, lorsqu'ils envoient des événements en continu, peuvent empêcher le SoC de en mode suspendu, mais si aucun événement n'est nécessaire, le wakelock doit être libéré.

Si enabled est défini sur 1 et que le capteur est déjà activé, cette fonction n'est pas exécutée et aboutit.

Si enabled est égal à 0 et que le capteur est déjà désactivé, cette fonction est une opération sans effet et aboutit.

Cette fonction renvoie 0 en cas de réussite et un numéro d'erreur négatif dans le cas contraire.

batch(capteur, indicateurs, période d'échantillonnage, latence maximale des rapports)

int (*batch)(
     struct sensors_poll_device_1* dev,
     int sensor_handle,
     int flags,
     int64_t sampling_period_ns,
     int64_t max_report_latency_ns);

Définit les paramètres d'un capteur, y compris la fréquence d'échantillonnage et la latence maximale des rapports. Cette fonction peut être appelée lorsque le capteur est activé, Dans ce cas, les mesures des capteurs ne doivent pas être perdues. d'un taux d'échantillonnage à l'autre ne peuvent pas entraîner de pertes d'événements, passer d'une latence maximale élevée à une faible latence maximale des rapports la latence.

sensor_handle est la poignée du capteur à configurer.

flags n'est actuellement pas utilisé.

sampling_period_ns est la période d'échantillonnage à laquelle le capteur doit s'exécuter, en nanosecondes. Voir sampling_period_ns pour plus de détails.

max_report_latency_ns est la durée maximale avant laquelle les événements peuvent être avant d'être transmis via le HAL, en nanosecondes. Pour en savoir plus, consultez le paragraphe max_report_latency_ns.

Cette fonction renvoie 0 en cas de réussite et un numéro d'erreur négatif dans le cas contraire.

setDelay(capteur, période d'échantillonnage)

int (*setDelay)(
     struct sensors_poll_device_t *dev,
     int sensor_handle,
     int64_t sampling_period_ns);

Après la version 1.0 de HAL, cette fonction est obsolète et n'est jamais appelée. À la place, la fonction batch est appelée pour définir le paramètre sampling_period_ns.

Dans la version 1.0 de HAL, setDelay était utilisé au lieu du lot pour définir sampling_period_ns.

flush(capteur)

int (*flush)(struct sensors_poll_device_1* dev, int sensor_handle);

Ajoutez un événement de vidage complet à la fin du FIFO matériel pour le capteur spécifié et videz le FIFO. ces événements sont diffusés normalement (comme si la latence maximale des rapports expirée) et supprimée du FIFO.

Le vidage se produit de manière asynchrone (c'est-à-dire que cette fonction doit renvoyer immédiatement un résultat). Si l'implémentation utilise un seul FIFO pour plusieurs capteurs, celui-ci est et l'événement de vidage complet n'est ajouté que pour le capteur spécifié.

Si le capteur spécifié ne comporte pas de FIFO (aucune mise en mémoire tampon n'est possible) ou si le FIFO était vide au moment de l'appel, flush doit toujours réussir et envoyer un événement de vidage terminé pour ce capteur. Cela s'applique à tous les capteurs que les capteurs uniques.

Lorsque flush est appelé, même si un événement de vidage est déjà dans la file d'attente FIFO de ce capteur, un événement supplémentaire doit être créé et ajouté à la fin de la file d'attente FIFO, et la file d'attente FIFO doit être vidangée. Le nombre d'appels flush doit être égal au nombre d'événements de vidage complet créés.

flush ne s'applique pas aux capteurs à déclenchement unique. Si sensor_handle fait référence à un capteur à déclenchement unique, flush doit renvoyer -EINVAL et ne générer aucun événement de vidage des métadonnées complètes.

Cette fonction renvoie 0 en cas de réussite, -EINVAL si le capteur spécifié est un capteur one-shot ou n'était pas activé, et un nombre d'erreur négatif dans le cas contraire.

poll()

int (*poll)(struct sensors_poll_device_t *dev, sensors_event_t* data, int
  count);

Renvoie un tableau de données de capteurs en remplissant l'argument data. Cette fonction doit être bloqué jusqu'à ce que des événements soient disponibles. Il renvoie le nombre d'événements lus en cas de réussite ou un numéro d'erreur négatif en cas d'erreur.

Le nombre d'événements renvoyés dans data doit être inférieur ou égal à l'argument count. Cette fonction ne renvoie jamais 0 (aucun événement).

Séquence d'appels

Lorsque l'appareil démarre, get_sensors_list est appelé.

Lorsqu'un capteur est activé, la fonction batch est appelée avec les paramètres demandés, suivie de activate(..., enable=1).

Notez que dans la version 1_0 de HAL, l'ordre était inverse: activate a été appelé. en premier, suivi de set_delay.

Lorsque les caractéristiques demandées d'un capteur changent lorsqu'il est activé, la fonction batch est appelée.

flush peut être appelé à tout moment, même sur des capteurs non activés (auquel cas la valeur -EINVAL doit être renvoyée)

Lorsqu'un capteur est désactivé, activate(..., enable=0) est appelé.

Parallèlement à ces appels, la fonction poll est appelée à plusieurs reprises pour : demander des données. poll peut être appelé même si aucun capteur n'est activé.

sensors_module_t

sensors_module_t est le type utilisé pour créer le module matériel Android pour les capteurs. L'implémentation du HAL doit définir un objet HAL_MODULE_INFO_SYM de ce type pour exposer la fonction get_sensors_list. Consultez le définition de sensors_module_t dans sensors.h et de la définition de hw_module_t pour en savoir plus.

sensors_poll_device_t / sensors_poll_device_1_t

sensors_poll_device_1_t contient le reste des méthodes définies ci-dessus : activate, batch, flush et poll. Son champ common (de type hw_device_t) définit le numéro de version du HAL.

sensor_t

sensor_t représente un capteur Android. Voici quelques-uns de ses champs importants:

name:chaîne visible par l'utilisateur et représentant le capteur. Cette chaîne contient souvent le nom de la pièce du capteur sous-jacent, le type du capteur et s'il s'agit d'un capteur de réveil. Exemple : "Accéléromètre LIS2HH12". "MAX21000 Uncalibrated Gyroscope", "BMP280 Wake-up Barometer", "MPU6515 Game" "Vecteur de rotation"

handle : entier utilisé pour faire référence au capteur lors de son enregistrement ou de la génération d'événements à partir de celui-ci.

type:type de capteur. Pour en savoir plus, consultez la section Que sont les capteurs Android ?, qui explique le type de capteur, et Types de capteurs pour connaître les types de capteurs officiels. Pour Types de capteurs non officiels, type doit commencer par SENSOR_TYPE_DEVICE_PRIVATE_BASE

stringType : type du capteur sous forme de chaîne. Lorsque le type du capteur est officiel (SENSOR_STRING_TYPE_*). Lorsque le capteur possède un type spécifique au fabricant, stringType doit commencer par le nom de domaine inversé du fabricant. Par exemple, un capteur (par exemple, (détecteur de licorne), défini par l'équipe Cool-product Fictif-Entreprise pourrait utiliser stringType=”com.fictional_company.cool_product.unicorn_detector” stringType permet d'identifier de manière unique les capteurs non officiels. de données. Consultez la page sensors.h pour en savoir plus sur les types et les chaînes. de données.

requiredPermission : chaîne représentant l'autorisation dont les applications doivent disposer pour voir le capteur, s'y enregistrer et recevoir ses données. Une chaîne vide signifie que les applications ne nécessitent aucune autorisation accéder à ce capteur. Certains types de capteurs, tels que le moniteur de fréquence cardiaque, ont un requiredPermission obligatoire. Tous les capteurs fournissant des informations les informations sur l'utilisateur (comme la fréquence cardiaque) doivent être protégées par un l'autorisation.

flags : indicateurs de ce capteur, qui définissent le mode de création de rapports du capteur et s'il s'agit d'un capteur de réveil ou non. Par exemple, un capteur d'activation ponctuelle aura flags = SENSOR_FLAG_ONE_SHOT_MODE | SENSOR_FLAG_WAKE_UP. Les bits de l'indicateur qui ne sont pas utilisés dans la version actuelle du HAL doivent être laissés égaux à 0.

maxRange:valeur maximale que le capteur peut signaler, dans la même unité que la valeur les valeurs enregistrées. Le capteur doit pouvoir transmettre des valeurs sans saturer dans un rayon de [-maxRange; maxRange]. Notez que cela correspond à la plage totale au sens générique est 2*maxRange. Lorsque le capteur indique des valeurs supérieures à plusieurs axes, la plage s'applique à chacun d'entre eux. Par exemple, "+/- 2g" l'accéléromètre indique maxRange = 2*9.81 = 2g.

résolution:la plus petite différence de valeur que le capteur peut mesurer. Généralement calculé en fonction de maxRange et du nombre de bits dans la mesure.

power : coût énergétique de l'activation du capteur, en milliampères. C'est presque toujours plus que la consommation d'énergie indiquée dans du capteur sous-jacent. Voir Capteurs de base != Physique capteurs pour en savoir plus, et consultez l'article sur la mesure de la puissance pour savoir comment mesurer la consommation d'énergie d'un capteur. Si la consommation d'énergie du capteur dépend de la mobilité de l'appareil, la consommation d'énergie en mouvement est celle indiquée dans le champ power.

minDelay : pour les capteurs continus, période d'échantillonnage, en microsecondes, correspondant au taux le plus rapide compatible avec le capteur. Pour en savoir plus sur l'utilisation de cette valeur, consultez sampling_period_ns. Attention : minDelay est exprimé en microsecondes alors que sampling_period_ns correspond à nanosecondes. Pour les capteurs en cas de modification et les capteurs en mode de création de rapports spéciaux, sauf indication contraire, minDelay doit être défini sur 0. Pour les capteurs one-shot, doit être définie sur -1.

maxDelay:pour les capteurs en continu et en cas de changement, l'échantillonnage moyenne, exprimée en microsecondes, correspondant à la vitesse la plus lente compatibles. Voir sampling_period_ns pour des détails sur l'utilisation de cette valeur. Attention : maxDelay est exprimé en microsecondes alors que sampling_period_ns correspond à nanosecondes. Pour les capteurs spéciaux et à usage unique, maxDelay doit être défini sur 0.

fifoRéservéEventCount:nombre d'événements réservés pour ce capteur dans le champ FIFO matériel. Si un FIFO dédié est disponible pour ce capteur, fifoReservedEventCount correspond à la taille de ce FIFO dédié. Si le FIFO est partagée avec d'autres capteurs, fifoReservedEventCount est la taille de la partie de le FIFO réservé à ce capteur. Sur la plupart des systèmes FIFO partagés et sur systèmes sans FIFO matériel, cette valeur est 0.

fifoMaxEventCount:nombre maximal d'événements pouvant dans les FIFO de ce capteur. Cette valeur est toujours supérieure ou égale à fifoReservedEventCount Cette valeur permet d'estimer la rapidité avec laquelle la file d'attente FIFO se remplit lors de l'enregistrement auprès du capteur à un débit spécifique, en supposant qu'aucun autre capteur n'est activé. Sur les systèmes qui n'ont pas FIFO matériel, fifoMaxEventCount est 0. Pour en savoir plus, consultez Grouper les requêtes.

Pour les capteurs disposant d'un type de capteur officiel, certains champs sont écrasés par le framework. C'est le cas, par exemple, des capteurs de l'accéléromètre. sont tenus d'avoir un mode de création de rapport continu, et les moniteurs de fréquence cardiaque sont d'être protégés par le SENSOR_PERMISSION_BODY_SENSORS l'autorisation.

sensors_event_t

Les événements de capteur générés par les capteurs Android et signalés via la fonction poll sont de type type sensors_event_t. Voici quelques champs importants de sensors_event_t :

version:doit être sizeof(struct sensors_event_t)

sensor:handle du capteur ayant généré l'événement, tel que défini par sensor_t.handle

type : type du capteur qui a généré l'événement, tel que défini par sensor_t.type.

timestamp : horodatage de l'événement en nanosecondes. C'est l'heure à laquelle (un pas a été effectué ou une mesure a été effectuée par l'accéléromètre), et non à l'heure à laquelle l'événement a été signalé. timestamp doit être synchronisé avec le elapsedRealtimeNano et, dans le cas de capteurs continus, la gigue doit être petite. Le filtrage du code temporel est parfois nécessaire pour respecter le CDD comme n'utiliser que le temps d'interruption SoC pour définir les horodatages provoque une gigue trop élevée. Si vous n'utilisez que le temps de puce du capteur les codes temporels peuvent provoquer une désynchronisation horloge elapsedRealtimeNano, car l'horloge du capteur dérive.

Données et champs qui se chevauchent : valeurs mesurées par le capteur. La signification et les unités de ces champs sont propres à chaque capteur. de mots clés. Pour obtenir une description des champs de données, consultez sensors.h et la définition des différents types de capteurs. Pour certains capteurs, la précision des mesures est également indiquée dans les données, via un champ status. Ce champ n'est transmis que pour certains types de capteurs, et apparaît au niveau de la couche du SDK en tant que valeur de précision. Pour ces capteurs, le fait que le champ "status" est mentionné dans leur type de capteur. définition.

Événements de vidage complet des métadonnées

Les événements de métadonnées sont du même type que les événements de capteurs normaux: sensors_event_meta_data_t = sensors_event_t Elles sont renvoyées avec et d'autres événements de capteurs. Ils possèdent les champs suivants:

version:doit être META_DATA_VERSION

type : doit être SENSOR_TYPE_META_DATA

sensor, reserved et timestamp : doit être égal à 0

meta_data.what : contient le type de métadonnées de cet événement. Il n'existe actuellement qu'un seul type de métadonnées valide : META_DATA_FLUSH_COMPLETE.

Les événements META_DATA_FLUSH_COMPLETE représentent la fin du vidage d'un FIFO de capteur. Lorsque meta_data.what=META_DATA_FLUSH_COMPLETE, meta_data.sensor doit être défini sur la poignée du capteur qui a été effacé. Il s'agit généré quand et seulement lorsque flush est appelé sur un capteur. Consultez la section sur Pour en savoir plus, consultez la fonction flush.