advertiser.h

/* Copyright (c) 2010 - 2020, Nordic Semiconductor ASA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 * Semiconductor ASA integrated circuit in a product or a software update for
 * such product, must reproduce the above copyright notice, this list of
 * conditions and the following disclaimer in the documentation and/or other
 * materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 * contributors may be used to endorse or promote products derived from this
 * software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 * Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 * engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef ADVERTISER_H__
#define ADVERTISER_H__

#include "broadcast.h"
#include "timer_scheduler.h"
#include "packet_buffer.h"
#include "nrf_mesh_defines.h"
#include "nrf_mesh_config_bearer.h"
#include "nrf_mesh.h"
#include "bearer_event.h"

#define ADVERTISER_INTERVAL_RANDOMIZATION_US MS_TO_US(10)

#define ADVERTISER_REPEAT_INFINITE 0xFF

#define ADVERTISER_PACKET_BUFFER_PACKET_MAXLEN (sizeof(packet_buffer_packet_t) + sizeof(adv_packet_t))

typedef struct
{
 nrf_mesh_tx_token_t token;
 struct
 {
 uint8_t repeats;
 } config;
 packet_t packet __attribute__((aligned(WORD_SIZE)));
} adv_packet_t;

typedef struct
{
 uint8_t channel_map[BEARER_ADV_CHANNELS_MAX];
 uint8_t count;
 bool randomize_order;
} advertiser_channels_t;


typedef struct
{
 ble_gap_addr_t adv_addr;
 uint32_t advertisement_interval_us;
 advertiser_channels_t channels;
} advertiser_config_t;

typedef struct advertiser_t advertiser_t;

typedef void (*advertiser_tx_complete_cb_t)(advertiser_t * p_adv, nrf_mesh_tx_token_t token, timestamp_t timestamp);

typedef struct
{
 nrf_mesh_tx_token_t token; 
 timestamp_t timestamp; 
} advertiser_tx_complete_params_t;

struct advertiser_t
{
 bool enabled; 
 adv_packet_t * p_packet; 
 broadcast_t broadcast; 
 timer_event_t timer; 
 packet_buffer_t buf; 
 advertiser_config_t config; 
 advertiser_tx_complete_cb_t tx_complete_callback; 
 bearer_event_sequential_t tx_complete_event; 
 advertiser_tx_complete_params_t tx_complete_params; 
};

void advertiser_init(void);

void advertiser_instance_init(advertiser_t * p_adv,
 advertiser_tx_complete_cb_t tx_complete_cb,
 uint8_t * p_buffer,
 uint32_t buffer_size);

void advertiser_enable(advertiser_t * p_adv);

void advertiser_disable(advertiser_t * p_adv);

adv_packet_t * advertiser_packet_alloc(advertiser_t * p_adv, uint32_t adv_payload_size);

void advertiser_packet_send(advertiser_t * p_adv, adv_packet_t * p_packet);

void advertiser_packet_discard(advertiser_t * p_adv, adv_packet_t * p_packet);

void advertiser_config_set(advertiser_t * p_adv, const advertiser_config_t * p_config);

void advertiser_config_get(const advertiser_t * p_adv, advertiser_config_t * p_config);

void advertiser_channels_set(advertiser_t * p_adv, const advertiser_channels_t * p_channels);

void advertiser_address_set(advertiser_t * p_adv, const ble_gap_addr_t * p_addr);

static inline void advertiser_address_get(const advertiser_t * p_adv, ble_gap_addr_t * p_addr)
{
 memcpy(p_addr, &p_adv->config.adv_addr, sizeof(ble_gap_addr_t));
}

void advertiser_interval_set(advertiser_t * p_adv, uint32_t interval_ms);

static inline uint32_t advertiser_interval_get(const advertiser_t * p_adv)
{
 return US_TO_MS(p_adv->config.advertisement_interval_us);
}

void advertiser_tx_power_set(advertiser_t * p_adv, radio_tx_power_t tx_power);

static inline radio_tx_power_t advertiser_tx_power_get(const advertiser_t * p_adv)
{
 return p_adv->broadcast.params.radio_config.tx_power;
}

void advertiser_flush(advertiser_t * p_adv);

void advertiser_address_default_get(ble_gap_addr_t * p_addr);

static inline bool advertiser_is_enabled(const advertiser_t * p_adv)
{
 return p_adv->enabled;
}

#endif /* ADVERTISER_H__ */