lib_aci.h

Go to the documentation of this file.

/* Copyright (c) 2014, Nordic Semiconductor ASA
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef LIB_ACI_H__
#define LIB_ACI_H__

#ifdef __cplusplus
extern "C" {
#endif

#include "hal_platform.h"
#include "hal_aci_tl.h"
#include "aci_queue.h"
#include "aci.h"
#include "aci_cmds.h"
#include "aci_evts.h"

#define EVT_CMD_RESPONSE_MIN_LENGTH              3

#define PIPES_ARRAY_SIZE                ((ACI_DEVICE_MAX_PIPES + 7)/8)

/* Same size as a hal_aci_data_t */
typedef struct {
  uint8_t   debug_byte;
  aci_evt_t evt;
} _aci_packed_ hal_aci_evt_t;

ACI_ASSERT_SIZE(hal_aci_evt_t, 34);

typedef struct
{
  uint8_t  location; 
  aci_pipe_type_t   pipe_type;
} services_pipe_type_mapping_t;

typedef struct aci_setup_info_t
{
  services_pipe_type_mapping_t *services_pipe_type_mapping;
  uint8_t                       number_of_pipes;
  hal_aci_data_t               *setup_msgs;
  uint8_t                       num_setup_msgs;
} aci_setup_info_t;



// aci_struct that will contain
// total initial credits
// current credit
// current state of the aci (setup/standby/active/sleep)
// open remote pipe pending
// close remote pipe pending
// Current pipe available bitmap
// Current pipe closed bitmap
// Current connection interval, slave latency and link supervision timeout
// Current State of the the GATT client (Service Discovery status)
// Relationship of bond to peer address
typedef struct aci_state_t
{
    aci_pins_t                    aci_pins;                               /* Pins on the MCU used to connect to the nRF8001 */
    aci_setup_info_t              aci_setup_info;                         /* Data structures that are created from nRFgo Studio */
    uint8_t                       bonded;                                 /* ( aci_bond_status_code_t ) Is the nRF8001 bonded to a peer device */
    uint8_t                       data_credit_total;                      /* Total data credit available for the specific version of the nRF8001, total equals available when a link is established */
    aci_device_operation_mode_t   device_state;                           /* Operating mode of the nRF8001 */

    /* */

    /* Start : Variables that are valid only when in a connection */
    uint8_t                       data_credit_available;                  /* Available data credits at a specific point of time, ACI_EVT_DATA_CREDIT updates the available credits */

    uint16_t                      connection_interval;                    /* Multiply by 1.25 to get the connection interval in milliseconds*/
    uint16_t                      slave_latency;                          /* Number of consecutive connection intervals that the nRF8001 is not required to transmit. Use this to save power */
    uint16_t                      supervision_timeout;                    /* Multiply by 10 to get the supervision timeout in milliseconds */

    uint8_t                       pipes_open_bitmap[PIPES_ARRAY_SIZE];    /* Bitmap -> pipes are open and can be used for sending data over the air */
    uint8_t                       pipes_closed_bitmap[PIPES_ARRAY_SIZE];  /* Bitmap -> pipes are closed and cannot be used for sending data over the air */
    bool                          confirmation_pending;                   /* Attribute protocol Handle Value confirmation is pending for a Handle Value Indication
                                                                        (ACK is pending for a TX_ACK pipe) on local GATT Server*/
    /* End : Variables that are valid only when in a connection */

} aci_state_t;



#define DISCONNECT_REASON_CX_TIMEOUT                 0x08
#define DISCONNECT_REASON_CX_CLOSED_BY_PEER_DEVICE   0x13
#define DISCONNECT_REASON_POWER_LOSS                 0x14
#define DISCONNECT_REASON_CX_CLOSED_BY_LOCAL_DEVICE  0x16
#define DISCONNECT_REASON_ADVERTISER_TIMEOUT         0x50



void lib_aci_debug_print(bool enable);

void lib_aci_pin_reset(void);

void lib_aci_init(aci_state_t *aci_stat, bool debug);


uint8_t lib_aci_get_nb_available_credits(aci_state_t *aci_stat);

uint16_t lib_aci_get_cx_interval_ms(aci_state_t *aci_stat);

uint16_t lib_aci_get_cx_interval(aci_state_t *aci_stat);

uint16_t lib_aci_get_slave_latency(aci_state_t *aci_stat);

bool lib_aci_is_pipe_available(aci_state_t *aci_stat, uint8_t pipe);

bool lib_aci_is_pipe_closed(aci_state_t *aci_stat, uint8_t pipe);

bool lib_aci_is_discovery_finished(aci_state_t *aci_stat);





bool lib_aci_sleep(void);

bool lib_aci_radio_reset(void);

bool lib_aci_direct_connect(void);

bool lib_aci_device_version(void);

bool lib_aci_get_address(void);

bool lib_aci_get_temperature(void);

bool lib_aci_get_battery_level(void);



bool lib_aci_wakeup(void);



bool lib_aci_test(aci_test_mode_change_t enter_exit_test_mode);

bool lib_aci_set_tx_power(aci_device_output_power_t tx_power);

bool lib_aci_connect(uint16_t run_timeout, uint16_t adv_interval);

bool lib_aci_bond(uint16_t run_timeout, uint16_t adv_interval);

bool lib_aci_disconnect(aci_state_t *aci_stat, aci_disconnect_reason_t reason);

bool lib_aci_set_local_data(aci_state_t *aci_stat, uint8_t pipe, uint8_t *value, uint8_t size);

bool lib_aci_broadcast(const uint16_t timeout, const uint16_t adv_interval);

bool lib_aci_open_adv_pipe(const uint8_t pipe);


bool lib_aci_open_adv_pipes(const uint8_t * const adv_service_data_pipes);





bool lib_aci_set_app_latency(uint16_t latency, aci_app_latency_mode_t latency_mode);

bool lib_aci_open_remote_pipe(aci_state_t *aci_stat, uint8_t pipe);

bool lib_aci_close_remote_pipe(aci_state_t *aci_stat, uint8_t pipe);

bool lib_aci_send_data(uint8_t pipe, uint8_t *value, uint8_t size);

bool lib_aci_request_data(aci_state_t *aci_stat, uint8_t pipe);

bool lib_aci_change_timing(uint16_t minimun_cx_interval, uint16_t maximum_cx_interval, uint16_t slave_latency, uint16_t timeout);

bool lib_aci_change_timing_GAP_PPCP(void);

bool lib_aci_send_ack(aci_state_t *aci_stat, const uint8_t pipe);

bool lib_aci_send_nack(aci_state_t *aci_stat, const uint8_t pipe, const uint8_t error_code);

bool lib_aci_read_dynamic_data(void);

bool lib_aci_write_dynamic_data(uint8_t sequence_number, uint8_t* dynamic_data, uint8_t length);


bool lib_aci_bond_request(void);

bool lib_aci_set_key(aci_key_type_t key_rsp_type, uint8_t *key, uint8_t len);





bool lib_aci_echo_msg(uint8_t message_size, uint8_t *message_data);

bool lib_aci_dtm_command(uint8_t dtm_command_msbyte, uint8_t dtm_command_lsbyte);

bool lib_aci_event_get(aci_state_t *aci_stat, hal_aci_evt_t * aci_evt);

bool lib_aci_event_peek(hal_aci_evt_t *p_aci_evt_data);

void lib_aci_flush(void);

 bool lib_aci_event_queue_full(void);

 bool lib_aci_event_queue_empty(void);

 bool lib_aci_command_queue_full(void);

 bool lib_aci_command_queue_empty(void);


#ifdef __cplusplus
}
#endif

#endif /* LIB_ACI_H__ */