device.h

Go to the documentation of this file.

#pragma once
#include <picofuse/hw/wifi.h>
#include <picofuse/sys.h>
#include <stdbool.h>
#include <stdint.h>

#ifndef HID_DEVICE_CAPACITY
#define HID_DEVICE_CAPACITY 32u
#endif

#ifndef HID_DEVICE_CONTEXT_SIZE
#define HID_DEVICE_CONTEXT_SIZE 32u
#endif

// TYPES

typedef struct hid_t hid_t;

typedef struct hid_device_t hid_device_t;

typedef enum {
  hid_type_none = 0,
  hid_type_gpio = 1,
  hid_type_timer = 2,
  hid_type_signal = 3,
  hid_type_evdev = 4,
  hid_type_usb = 5,
  hid_type_wifi = 6,
  hid_type_bluetooth = 7,
  hid_type_infrared = 8,
  hid_type_other = 9,
  hid_type_iostream = 10,
} hid_type_t;

typedef struct {
  bool (*init)(hid_device_t *device, void *userdata); 
  bool (*read)(hid_device_t *device, void *userdata); 
  bool (*deinit)(hid_device_t *device, void *userdata); 
} hid_device_callbacks_t;

typedef enum {
  hid_class_unknown = 0,
  hid_class_keyboard = 1,
  hid_class_mouse = 2,
  hid_class_joystick = 3,
  hid_class_touchscreen = 4,
  hid_class_sensor = 5,
} hid_class_t;

// LIFECYCLE

hid_t *hid_init(sys_event_queue_t *queue);

void hid_deinit(hid_t *instance);

bool hid_poll(hid_t *instance);

// METHODS

hid_device_t *hid_register(hid_t *instance, const char *name, uint32_t id,
                           hid_type_t type, hid_class_t hid_class,
                           uint32_t polling_interval_ms, void *userdata,
                           hid_device_callbacks_t callbacks);

hid_device_t *hid_register_gpio_input(hid_t *instance, uint8_t bank,
                                      uint8_t pin, uint16_t keycode,
                                      void *userdata);

hid_device_t *hid_register_gpio_pullup(hid_t *instance, uint8_t bank,
                                       uint8_t pin, uint16_t keycode,
                                       void *userdata);

hid_device_t *hid_register_gpio_pulldown(hid_t *instance, uint8_t bank,
                                         uint8_t pin, uint16_t keycode,
                                         void *userdata);

hid_device_t *hid_register_adc(hid_t *instance, uint8_t channel,
                               const char *metric_name, uint16_t num_samples,
                               uint32_t polling_interval_ms, void *userdata);

hid_device_t *hid_register_temperature(hid_t *instance,
                                       uint32_t polling_interval_ms,
                                       void *userdata);

hid_device_t *hid_register_user_button(hid_t *instance, uint16_t keycode,
                                       void *userdata);

hid_device_t *hid_register_timer(hid_t *instance, uint32_t id,
                                 uint32_t interval_ms, bool repeating,
                                 void *userdata);

hid_device_t *hid_register_signal(hid_t *instance, void *userdata);

hid_device_t *hid_register_wifi(hid_t *instance, hw_wifi_t *wifi,
                                void *userdata);

hid_device_t *hid_register_iostream(hid_t *instance, sys_iostream_t *stream,
                                    void *userdata);

bool hid_deregister(hid_t *instance, hid_device_t *device);

// PROPERTIES

hid_device_t *hid_device_next(hid_device_t *device);

bool hid_device_info(const hid_device_t *device, const char **out_name,
                     uint32_t *out_id, hid_type_t *out_type,
                     hid_class_t *out_class);

void *hid_device_userdata(const hid_device_t *device);

void *hid_device_handle(const hid_device_t *device);