Contiki-NG
Loading...
Searching...
No Matches
ble-cc2650.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2017, Graz University of Technology
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the copyright holder nor the names of its
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
26 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
28 * OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31/**
32 * \file
33 * BLE radio for the TI CC26xx platform
34 *
35 * \author
36 * Michael Spoerk <michael.spoerk@tugraz.at>
37 */
38/*---------------------------------------------------------------------------*/
39#include "contiki.h"
40#include "dev/radio.h"
41#include "os/dev/ble-hal.h"
42#include "rf-core/ble-hal/ble-hal-cc26xx.h"
43
44#include <stdint.h>
45#include <string.h>
46/*---------------------------------------------------------------------------*/
47#include "sys/log.h"
48#define LOG_MODULE "RADIO"
49#define LOG_LEVEL LOG_LEVEL_MAIN
50/*---------------------------------------------------------------------------*/
51static uint16_t adv_interval;
52static ble_adv_type_t adv_type;
53static ble_addr_type_t adv_own_addr_type;
54static uint8_t adv_channel_map;
55static uint16_t buffer_size = 0;
56/*---------------------------------------------------------------------------*/
57static uint16_t scan_interval;
58static uint16_t scan_window;
59static ble_scan_type_t scan_type;
60static ble_addr_type_t scan_own_addr_type;
61/*---------------------------------------------------------------------------*/
62static ble_addr_type_t initiator_peer_addr_type;
63static uint8_t initiator_peer_addr[BLE_ADDR_SIZE];
64/*---------------------------------------------------------------------------*/
65static uint16_t connection_interval;
66static uint16_t connection_latency;
67static uint16_t connection_timeout;
68/*---------------------------------------------------------------------------*/
69static int
70init(void)
71{
72 int result = ble_hal.reset();
73 return result == BLE_RESULT_OK;
74}
75/*---------------------------------------------------------------------------*/
76static int
77send(const void *payload, unsigned short payload_len)
78{
79 uint8_t res;
80 res = ble_hal.send((void *)payload, payload_len);
81 LOG_DBG("ble-mode send() %d bytes\n", payload_len);
82 if(res == BLE_RESULT_OK) {
83 return RADIO_TX_OK;
84 } else {
85 LOG_ERR("ble-mode send() error: %d\n", res);
86 return RADIO_TX_ERR;
87 }
88}
89/*---------------------------------------------------------------------------*/
90static int
91on(void)
92{
93 return 1;
94}
95/*---------------------------------------------------------------------------*/
96static int
97off(void)
98{
99 ble_hal.disconnect(0, 0);
100 return 1;
101}
102/*---------------------------------------------------------------------------*/
103static radio_result_t
104get_value(radio_param_t param, radio_value_t *value)
105{
106 unsigned int temp;
107
108 if(!value) {
109 return RADIO_RESULT_INVALID_VALUE;
110 }
111
112 switch(param) {
113 case RADIO_CONST_CHANNEL_MIN:
114 *value = BLE_DATA_CHANNEL_MIN;
115 return RADIO_RESULT_OK;
116 case RADIO_CONST_CHANNEL_MAX:
117 *value = BLE_DATA_CHANNEL_MAX;
118 return RADIO_RESULT_OK;
119 case RADIO_CONST_BLE_BUFFER_SIZE:
120 if(buffer_size == 0) {
121 ble_hal.read_buffer_size((unsigned int *)&buffer_size, &temp);
122 }
123 memcpy(value, &buffer_size, 2);
124 return RADIO_RESULT_OK;
125 case RADIO_CONST_BLE_BUFFER_AMOUNT:
126 ble_hal.read_buffer_size(&temp, (unsigned int *)value);
127 return RADIO_RESULT_OK;
128 case RADIO_PARAM_BLE_CONN_INTERVAL:
129 ble_hal.read_connection_interval(0, (unsigned int *)value);
130 return RADIO_RESULT_OK;
131 default:
132 return RADIO_RESULT_NOT_SUPPORTED;
133 }
134}
135/*---------------------------------------------------------------------------*/
136static radio_result_t
137set_value(radio_param_t param, radio_value_t value)
138{
139 switch(param) {
140 case RADIO_PARAM_BLE_ADV_INTERVAL:
141 if((value > BLE_ADV_INTERVAL_MAX) || (value < BLE_ADV_INTERVAL_MIN)) {
142 return RADIO_RESULT_INVALID_VALUE;
143 }
144 adv_interval = (uint16_t)value;
145 return RADIO_RESULT_OK;
146 case RADIO_PARAM_BLE_ADV_TYPE:
147 adv_type = value;
148 return RADIO_RESULT_OK;
149 case RADIO_PARAM_BLE_ADV_OWN_ADDR_TYPE:
150 adv_own_addr_type = value;
151 return RADIO_RESULT_OK;
152 case RADIO_PARAM_BLE_ADV_CHANNEL_MAP:
153 adv_channel_map = value;
154 return RADIO_RESULT_OK;
155 case RADIO_PARAM_BLE_ADV_ENABLE:
156 if(value) {
157 /* set the advertisement parameter before enabling */
158 ble_hal.set_adv_param(adv_interval, adv_type,
159 adv_own_addr_type, adv_channel_map);
160 }
161 ble_hal.set_adv_enable(value);
162 return RADIO_RESULT_OK;
163 case RADIO_PARAM_BLE_SCAN_INTERVAL:
164 if((value > BLE_SCAN_INTERVAL_MAX) || (value < BLE_SCAN_INTERVAL_MIN)) {
165 return RADIO_RESULT_INVALID_VALUE;
166 }
167 scan_interval = (uint16_t)value;
168 return RADIO_RESULT_OK;
169 case RADIO_PARAM_BLE_SCAN_WINDOW:
170 if((value > BLE_SCAN_INTERVAL_MAX) || (value < BLE_SCAN_INTERVAL_MIN)) {
171 return RADIO_RESULT_INVALID_VALUE;
172 }
173 scan_window = (uint16_t)value;
174 return RADIO_RESULT_OK;
175 case RADIO_PARAM_BLE_SCAN_TYPE:
176 scan_type = value;
177 return RADIO_RESULT_OK;
178 case RADIO_PARAM_BLE_SCAN_OWN_ADDR_TYPE:
179 scan_own_addr_type = value;
180 return RADIO_RESULT_OK;
181 case RADIO_PARAM_BLE_SCAN_ENABLE:
182 if(value) {
183 ble_hal.set_scan_param(scan_type, scan_interval,
184 scan_window, scan_own_addr_type);
185 }
186 ble_hal.set_scan_enable(value, 0);
187 return RADIO_RESULT_OK;
188 case RADIO_PARAM_BLE_PEER_ADDR_TYPE:
189 initiator_peer_addr_type = value;
190 return RADIO_RESULT_OK;
191 case RADIO_PARAM_BLE_CONN_INTERVAL:
192 connection_interval = value;
193 return RADIO_RESULT_OK;
194 case RADIO_PARAM_BLE_CONN_LATENCY:
195 connection_latency = value;
196 return RADIO_RESULT_OK;
197 case RADIO_PARAM_BLE_CONN_SUPERVISION_TIMEOUT:
198 connection_timeout = value;
199 return RADIO_RESULT_OK;
200 case RADIO_PARAM_BLE_INITIATOR_ENABLE:
201 if(value) {
202 ble_hal.create_connection(scan_interval, scan_window,
203 initiator_peer_addr_type,
204 initiator_peer_addr,
205 scan_own_addr_type,
206 connection_interval,
207 connection_latency,
208 connection_timeout);
209 } else {
210 ble_hal.create_connection_cancel();
211 }
212 return RADIO_RESULT_OK;
213 case RADIO_PARAM_BLE_CONN_UPDATE:
214 if(!value) {
215 return RADIO_RESULT_INVALID_VALUE;
216 }
217 switch(ble_hal.connection_update(0, connection_interval, connection_latency, connection_timeout)) {
218 case BLE_RESULT_OK:
219 return RADIO_RESULT_OK;
220 case BLE_RESULT_NOT_SUPPORTED:
221 return RADIO_RESULT_NOT_SUPPORTED;
222 case BLE_RESULT_INVALID_PARAM:
223 return RADIO_RESULT_INVALID_VALUE;
224 case BLE_RESULT_ERROR:
225 return RADIO_RESULT_ERROR;
226 }
227 default:
228 return RADIO_RESULT_NOT_SUPPORTED;
229 }
230}
231/*---------------------------------------------------------------------------*/
232static radio_result_t
233get_object(radio_param_t param, void *dest, size_t size)
234{
235 switch(param) {
236 case RADIO_CONST_BLE_BD_ADDR:
237 if(size != BLE_ADDR_SIZE || !dest) {
238 return RADIO_RESULT_INVALID_VALUE;
239 }
240 ble_hal.read_bd_addr(dest);
241 return RADIO_RESULT_OK;
242 }
243 return RADIO_RESULT_NOT_SUPPORTED;
244}
245/*---------------------------------------------------------------------------*/
246static radio_result_t
247set_object(radio_param_t param, const void *src, size_t size)
248{
249 switch(param) {
250 case RADIO_PARAM_BLE_ADV_PAYLOAD:
251 if(size <= 0 || size >= BLE_ADV_DATA_LEN || !src) {
252 return RADIO_RESULT_INVALID_VALUE;
253 }
254 ble_hal.set_adv_data((unsigned short)size, (char *)src);
255 return RADIO_RESULT_OK;
256 case RADIO_PARAM_BLE_ADV_SCAN_RESPONSE:
257 if(size <= 0 || size >= BLE_SCAN_RESP_DATA_LEN || !src) {
258 return RADIO_RESULT_INVALID_VALUE;
259 }
260 ble_hal.set_scan_resp_data((unsigned short)size, (char *)src);
261 return RADIO_RESULT_OK;
262 case RADIO_PARAM_BLE_PEER_ADDR:
263 if(size <= 0 || size > BLE_ADDR_SIZE || !src) {
264 return RADIO_RESULT_INVALID_VALUE;
265 }
266 memcpy(initiator_peer_addr, src, size);
267 return RADIO_RESULT_OK;
268 }
269 return RADIO_RESULT_NOT_SUPPORTED;
270}
271/*---------------------------------------------------------------------------*/
272const struct radio_driver ble_cc2650_driver = {
273 init,
274 NULL,
275 NULL,
276 send,
277 NULL,
278 NULL,
279 NULL,
280 NULL,
281 on,
282 off,
283 get_value,
284 set_value,
285 get_object,
286 set_object,
287};
288/*---------------------------------------------------------------------------*/
ble-hal-cc26xx.h
BLE radio hardware abstraction for the TI CC26XX controller.
ble-hal.h
hardware abstraction for a BLE controller
off
static int off(void)
Definition cc2538-rf.c:533
get_object
static radio_result_t get_object(radio_param_t param, void *dest, size_t size)
Definition cc2538-rf.c:1069
set_object
static radio_result_t set_object(radio_param_t param, const void *src, size_t size)
Definition cc2538-rf.c:1110
on
static int on(void)
Definition cc2538-rf.c:517
init
static int init(void)
Definition cc2538-rf.c:556
value
static int value(int type)
Definition cc2538-temp-sensor.c:49
radio_result_t
enum radio_result_e radio_result_t
Radio return values when setting or getting radio parameters.
radio_value_t
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio.
Definition radio.h:88
RADIO_RESULT_ERROR
@ RADIO_RESULT_ERROR
An error occurred when getting/setting the parameter, but the arguments were otherwise correct.
Definition radio.h:488
RADIO_RESULT_NOT_SUPPORTED
@ RADIO_RESULT_NOT_SUPPORTED
The parameter is not supported.
Definition radio.h:481
RADIO_RESULT_INVALID_VALUE
@ RADIO_RESULT_INVALID_VALUE
The value argument was incorrect.
Definition radio.h:482
RADIO_RESULT_OK
@ RADIO_RESULT_OK
The parameter was set/read successfully.
Definition radio.h:480
RADIO_CONST_CHANNEL_MAX
@ RADIO_CONST_CHANNEL_MAX
The highest radio channel number.
Definition radio.h:316
RADIO_CONST_CHANNEL_MIN
@ RADIO_CONST_CHANNEL_MIN
The lowest radio channel number.
Definition radio.h:311
RADIO_TX_ERR
@ RADIO_TX_ERR
An error occurred during transmission.
Definition radio.h:506
RADIO_TX_OK
@ RADIO_TX_OK
TX was successful and where an ACK was requested one was received.
Definition radio.h:498
log.h
Header file for the logging system.
radio.h
Header file for the radio API.
radio_driver
The structure of a Contiki-NG radio device driver.
Definition radio.h:534