mqtt.h

Go to the documentation of this file.

#pragma once
#include <picofuse/net/types.h>
#include <stdbool.h>
#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

#define NET_MQTT_PORT 1883

#ifndef NET_MQTT_TOPIC_CAPACITY
#define NET_MQTT_TOPIC_CAPACITY 8
#endif

#ifndef NET_MQTT_TOPIC_FILTER_SIZE
#define NET_MQTT_TOPIC_FILTER_SIZE 128
#endif

// TYPES

typedef struct net_mqtt_t net_mqtt_t;

typedef enum {
  net_mqtt_qos_0, 
  net_mqtt_qos_1, 
  net_mqtt_qos_2, 
} net_mqtt_qos_t;

typedef struct {
  const char *client_id; 
  const char *username;  
  const char *password;  
  uint16_t keepalive_s;  
} net_mqtt_config_t;

typedef enum {
  net_mqtt_event_connected,    
  net_mqtt_event_disconnected, 
  net_mqtt_event_sent,         
  net_mqtt_event_subscribed,   
  net_mqtt_event_unsubscribed, 
  net_mqtt_event_received,     
  net_mqtt_event_error,        
} net_mqtt_event_type_t;

typedef struct {
  const char *topic;    
  uint32_t message_id;  
} net_mqtt_sent_t;

typedef struct {
  net_mqtt_qos_t granted_qos; 
  uint32_t topic_id;         
} net_mqtt_subscribed_t;

typedef struct {
  uint32_t topic_id; 
} net_mqtt_unsubscribed_t;

typedef struct {
  const char *topic;   
  const void *payload; 
  size_t payload_len;  
  bool retain;         
  uint32_t topic_id;   
} net_mqtt_received_t;

typedef enum {
  net_mqtt_error_write_failed, 
  net_mqtt_error_malformed,    
  net_mqtt_error_unexpected,   
  net_mqtt_error_timeout,      
  net_mqtt_error_refused,      
} net_mqtt_error_kind_t;

typedef enum {
  net_mqtt_action_none,        
  net_mqtt_action_publish,     
  net_mqtt_action_subscribe,   
  net_mqtt_action_unsubscribe, 
  net_mqtt_action_receive,     
  net_mqtt_action_ping,        
} net_mqtt_error_action_t;

typedef struct {
  net_mqtt_error_kind_t kind;     
  net_mqtt_error_action_t action; 
  uint32_t message_id; 
} net_mqtt_error_t;

typedef struct {
  net_mqtt_event_type_t type; 
  union {
    net_mqtt_sent_t sent;
    net_mqtt_subscribed_t subscribed;
    net_mqtt_unsubscribed_t unsubscribed;
    net_mqtt_received_t received;
    net_mqtt_error_t error;
  } data; 
} net_mqtt_event_t;

typedef void (*net_mqtt_event_callback_t)(net_mqtt_t *mqtt,
                                          const net_mqtt_event_t *event,
                                          void *userdata);

// LIFECYCLE

void net_mqtt_default_config(net_mqtt_config_t *config);

net_mqtt_t *net_mqtt_init(const net_addr_t *addr, uint16_t port,
                          uint32_t timeout_ms, const net_mqtt_config_t *config);

void net_mqtt_set_callback(net_mqtt_t *mqtt, net_mqtt_event_callback_t callback,
                           void *userdata);

void net_mqtt_deinit(net_mqtt_t *mqtt);

// CONNECTION

bool net_mqtt_connect(net_mqtt_t *mqtt);

void net_mqtt_disconnect(net_mqtt_t *mqtt);

// PUBLISH

uint32_t net_mqtt_publish(net_mqtt_t *mqtt, const char *topic,
                          const void *payload, size_t payload_len,
                          net_mqtt_qos_t qos, bool retain);

// SUBSCRIBE

uint32_t net_mqtt_subscribe(net_mqtt_t *mqtt, const char *topic,
                            net_mqtt_qos_t qos);

bool net_mqtt_unsubscribe(net_mqtt_t *mqtt, uint32_t topic_id);

const char *net_mqtt_topic_to_string(net_mqtt_t *mqtt, uint32_t topic_id);

size_t net_mqtt_error_to_string(const net_mqtt_error_t *error, char *buf,
                                size_t buf_size);

#ifdef __cplusplus
}
#endif