Devchannel Team / X_NUCLEO_IDB0XA1

HW layer for the Nucleo board, it only work with old BLE_API

Dependents:   Hello_BLE F446RE-BLE

Fork of X_NUCLEO_IDB0XA1 by ST

BlueNRGDevice.cpp@74:c4526f8284d5, 2015-06-16 (annotated)

Committer:
Antonio Vilei
Date:
Tue Jun 16 10:23:56 2015 +0200
Revision:
74:c4526f8284d5
Parent:
70:d20d30f59b1c
Child:
77:332b416123b4
Use mbed C++ API for BlueNRG Driver



Update the old driver and replace the low-level C functions

with the C++ API for SPI and InterruptIn.

Fix issues with interrupt initialization caused by the old driver

(calling mbed's private functions to setup SPI and irq and messing

up other code based on InterruptIn, e.g. button.)



Signed-off-by: Antonio Vilei <antonio.vilei@st.com>

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Silvio Lucio Oliva 70:d20d30f59b1c 1 /* mbed Microcontroller Library
Silvio Lucio Oliva 70:d20d30f59b1c 2 * Copyright (c) 2006-2013 ARM Limited
Silvio Lucio Oliva 70:d20d30f59b1c 3 *
Silvio Lucio Oliva 70:d20d30f59b1c 4 * Licensed under the Apache License, Version 2.0 (the "License");
Silvio Lucio Oliva 70:d20d30f59b1c 5 * you may not use this file except in compliance with the License.
Silvio Lucio Oliva 70:d20d30f59b1c 6 * You may obtain a copy of the License at
Silvio Lucio Oliva 70:d20d30f59b1c 7 *
Silvio Lucio Oliva 70:d20d30f59b1c 8 * http://www.apache.org/licenses/LICENSE-2.0
Silvio Lucio Oliva 70:d20d30f59b1c 9 *
Silvio Lucio Oliva 70:d20d30f59b1c 10 * Unless required by applicable law or agreed to in writing, software
Silvio Lucio Oliva 70:d20d30f59b1c 11 * distributed under the License is distributed on an "AS IS" BASIS,
Silvio Lucio Oliva 70:d20d30f59b1c 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Silvio Lucio Oliva 70:d20d30f59b1c 13 * See the License for the specific language governing permissions and
Silvio Lucio Oliva 70:d20d30f59b1c 14 * limitations under the License.
Silvio Lucio Oliva 70:d20d30f59b1c 15 */
Silvio Lucio Oliva 70:d20d30f59b1c 16
Silvio Lucio Oliva 70:d20d30f59b1c 17 /**
Silvio Lucio Oliva 70:d20d30f59b1c 18 ******************************************************************************
Silvio Lucio Oliva 70:d20d30f59b1c 19 * @file BlueNRGDevice.cpp
Silvio Lucio Oliva 70:d20d30f59b1c 20 * @author STMicroelectronics
Silvio Lucio Oliva 70:d20d30f59b1c 21 * @brief Implementation of BLEDeviceInstanceBase
Silvio Lucio Oliva 70:d20d30f59b1c 22 ******************************************************************************
Silvio Lucio Oliva 70:d20d30f59b1c 23 * @copy
Silvio Lucio Oliva 70:d20d30f59b1c 24 *
Silvio Lucio Oliva 70:d20d30f59b1c 25 * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
Silvio Lucio Oliva 70:d20d30f59b1c 26 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
Silvio Lucio Oliva 70:d20d30f59b1c 27 * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
Silvio Lucio Oliva 70:d20d30f59b1c 28 * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
Silvio Lucio Oliva 70:d20d30f59b1c 29 * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
Silvio Lucio Oliva 70:d20d30f59b1c 30 * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
Silvio Lucio Oliva 70:d20d30f59b1c 31 *
Silvio Lucio Oliva 70:d20d30f59b1c 32 * <h2><center>&copy; COPYRIGHT 2013 STMicroelectronics</center></h2>
Silvio Lucio Oliva 70:d20d30f59b1c 33 */
Silvio Lucio Oliva 70:d20d30f59b1c 34
Silvio Lucio Oliva 70:d20d30f59b1c 35 /** @defgroup BlueNRGDevice
Silvio Lucio Oliva 70:d20d30f59b1c 36 * @brief BlueNRG BLE_API Device Adaptation
Silvio Lucio Oliva 70:d20d30f59b1c 37 * @{
Silvio Lucio Oliva 70:d20d30f59b1c 38 */
Silvio Lucio Oliva 70:d20d30f59b1c 39
Silvio Lucio Oliva 70:d20d30f59b1c 40 #include "mbed.h"
Silvio Lucio Oliva 70:d20d30f59b1c 41 #include "BlueNRGDevice.h"
Silvio Lucio Oliva 70:d20d30f59b1c 42 #include "BlueNRGGap.h"
Silvio Lucio Oliva 70:d20d30f59b1c 43 #include "BlueNRGGattServer.h"
Silvio Lucio Oliva 70:d20d30f59b1c 44
Silvio Lucio Oliva 70:d20d30f59b1c 45 #include "btle.h"
Silvio Lucio Oliva 70:d20d30f59b1c 46 #include "Utils.h"
Silvio Lucio Oliva 70:d20d30f59b1c 47 #include "osal.h"
Silvio Lucio Oliva 70:d20d30f59b1c 48
Antonio Vilei 74:c4526f8284d5 49 extern "C" {
Antonio Vilei 74:c4526f8284d5 50 #include "hci.h"
Antonio Vilei 74:c4526f8284d5 51 }
Antonio Vilei 74:c4526f8284d5 52
Antonio Vilei 74:c4526f8284d5 53 #define HEADER_SIZE 5
Antonio Vilei 74:c4526f8284d5 54 #define MAX_BUFFER_SIZE 255
Antonio Vilei 74:c4526f8284d5 55
Silvio Lucio Oliva 70:d20d30f59b1c 56 /**
Silvio Lucio Oliva 70:d20d30f59b1c 57 * The singleton which represents the BlueNRG transport for the BLEDevice.
Silvio Lucio Oliva 70:d20d30f59b1c 58 */
Antonio Vilei 74:c4526f8284d5 59 // FIXME: find a better way to create the BlueNRG device instance so that
Antonio Vilei 74:c4526f8284d5 60 // the pin names can be chosen by the users of this class
Antonio Vilei 74:c4526f8284d5 61 BlueNRGDevice bluenrgDeviceInstance(PA_7, PA_6, PB_3, PA_1, PA_8, PA_0);
Silvio Lucio Oliva 70:d20d30f59b1c 62
Silvio Lucio Oliva 70:d20d30f59b1c 63 /**
Silvio Lucio Oliva 70:d20d30f59b1c 64 * BLE-API requires an implementation of the following function in order to
Silvio Lucio Oliva 70:d20d30f59b1c 65 * obtain its transport handle.
Silvio Lucio Oliva 70:d20d30f59b1c 66 */
Silvio Lucio Oliva 70:d20d30f59b1c 67 BLEDeviceInstanceBase *
Silvio Lucio Oliva 70:d20d30f59b1c 68 createBLEDeviceInstance(void)
Silvio Lucio Oliva 70:d20d30f59b1c 69 {
Antonio Vilei 74:c4526f8284d5 70 return (&bluenrgDeviceInstance);
Silvio Lucio Oliva 70:d20d30f59b1c 71 }
Silvio Lucio Oliva 70:d20d30f59b1c 72
Silvio Lucio Oliva 70:d20d30f59b1c 73 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 74 /**
Silvio Lucio Oliva 70:d20d30f59b1c 75 @brief Constructor
Antonio Vilei 74:c4526f8284d5 76 * @param mosi mbed pin to use for MOSI line of SPI interface.
Antonio Vilei 74:c4526f8284d5 77 * @param miso mbed pin to use for MISO line of SPI interface.
Antonio Vilei 74:c4526f8284d5 78 * @param sck mbed pin to use for SCK line of SPI interface.
Antonio Vilei 74:c4526f8284d5 79 * @param cs mbed pin to use for not chip select line of SPI interface.
Antonio Vilei 74:c4526f8284d5 80 * @param irq mbed pin for BlueNRG IRQ
Silvio Lucio Oliva 70:d20d30f59b1c 81 */
Silvio Lucio Oliva 70:d20d30f59b1c 82 /**************************************************************************/
Antonio Vilei 74:c4526f8284d5 83 BlueNRGDevice::BlueNRGDevice(PinName mosi,
Antonio Vilei 74:c4526f8284d5 84 PinName miso,
Antonio Vilei 74:c4526f8284d5 85 PinName sck,
Antonio Vilei 74:c4526f8284d5 86 PinName cs,
Antonio Vilei 74:c4526f8284d5 87 PinName rst,
Antonio Vilei 74:c4526f8284d5 88 PinName irq) : spi_(mosi, miso, sck), nCS_(cs), rst_(rst), irq_(irq)
Silvio Lucio Oliva 70:d20d30f59b1c 89 {
Silvio Lucio Oliva 70:d20d30f59b1c 90 isInitialized = false;
Antonio Vilei 74:c4526f8284d5 91
Antonio Vilei 74:c4526f8284d5 92 // Setup the spi for 8 bit data, low clock polarity,
Antonio Vilei 74:c4526f8284d5 93 // 1-edge phase, with an 8MHz clock rate
Antonio Vilei 74:c4526f8284d5 94 spi_.format(8, 0);
Antonio Vilei 74:c4526f8284d5 95 spi_.frequency(8000000);
Antonio Vilei 74:c4526f8284d5 96
Antonio Vilei 74:c4526f8284d5 97 // Deselect the BlueNRG chip by keeping its nCS signal high
Antonio Vilei 74:c4526f8284d5 98 nCS_ = 1;
Antonio Vilei 74:c4526f8284d5 99
Antonio Vilei 74:c4526f8284d5 100 wait_us(500);
Silvio Lucio Oliva 70:d20d30f59b1c 101 }
Silvio Lucio Oliva 70:d20d30f59b1c 102
Silvio Lucio Oliva 70:d20d30f59b1c 103 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 104 /**
Silvio Lucio Oliva 70:d20d30f59b1c 105 @brief Destructor
Silvio Lucio Oliva 70:d20d30f59b1c 106 */
Silvio Lucio Oliva 70:d20d30f59b1c 107 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 108 BlueNRGDevice::~BlueNRGDevice(void)
Silvio Lucio Oliva 70:d20d30f59b1c 109 {
Silvio Lucio Oliva 70:d20d30f59b1c 110 }
Silvio Lucio Oliva 70:d20d30f59b1c 111
Silvio Lucio Oliva 70:d20d30f59b1c 112
Silvio Lucio Oliva 70:d20d30f59b1c 113 /**
Silvio Lucio Oliva 70:d20d30f59b1c 114 @brief Initialises anything required to start using BLE
Silvio Lucio Oliva 70:d20d30f59b1c 115 @param[in] void
Silvio Lucio Oliva 70:d20d30f59b1c 116 @returns ble_error_t
Silvio Lucio Oliva 70:d20d30f59b1c 117 */
Silvio Lucio Oliva 70:d20d30f59b1c 118 ble_error_t BlueNRGDevice::init(void)
Silvio Lucio Oliva 70:d20d30f59b1c 119 {
Antonio Vilei 74:c4526f8284d5 120 // Set the interrupt handler for the device
Antonio Vilei 74:c4526f8284d5 121 irq_.rise(&HCI_Isr);
Antonio Vilei 74:c4526f8284d5 122
Silvio Lucio Oliva 70:d20d30f59b1c 123 /* ToDo: Clear memory contents, reset the SD, etc. */
Antonio Vilei 74:c4526f8284d5 124 btle_init(BlueNRGGap::getInstance().getIsSetAddress());
Antonio Vilei 74:c4526f8284d5 125
Silvio Lucio Oliva 70:d20d30f59b1c 126 isInitialized = true;
Silvio Lucio Oliva 70:d20d30f59b1c 127
Silvio Lucio Oliva 70:d20d30f59b1c 128 return BLE_ERROR_NONE;
Silvio Lucio Oliva 70:d20d30f59b1c 129 }
Silvio Lucio Oliva 70:d20d30f59b1c 130
Silvio Lucio Oliva 70:d20d30f59b1c 131
Silvio Lucio Oliva 70:d20d30f59b1c 132 /**
Silvio Lucio Oliva 70:d20d30f59b1c 133 @brief Resets the BLE HW, removing any existing services and
Silvio Lucio Oliva 70:d20d30f59b1c 134 characteristics
Silvio Lucio Oliva 70:d20d30f59b1c 135 @param[in] void
Silvio Lucio Oliva 70:d20d30f59b1c 136 @returns ble_error_t
Silvio Lucio Oliva 70:d20d30f59b1c 137 */
Silvio Lucio Oliva 70:d20d30f59b1c 138 ble_error_t BlueNRGDevice::reset(void)
Silvio Lucio Oliva 70:d20d30f59b1c 139 {
Antonio Vilei 74:c4526f8284d5 140 wait_us(500);
Silvio Lucio Oliva 70:d20d30f59b1c 141
Silvio Lucio Oliva 70:d20d30f59b1c 142 /* Reset BlueNRG SPI interface */
Antonio Vilei 74:c4526f8284d5 143 rst_ = 0;
Antonio Vilei 74:c4526f8284d5 144 wait_us(5);
Antonio Vilei 74:c4526f8284d5 145 rst_ = 1;
Antonio Vilei 74:c4526f8284d5 146 wait_us(5);
Silvio Lucio Oliva 70:d20d30f59b1c 147
Silvio Lucio Oliva 70:d20d30f59b1c 148 /* Wait for the radio to come back up */
Antonio Vilei 74:c4526f8284d5 149 wait_us(500);
Silvio Lucio Oliva 70:d20d30f59b1c 150
Silvio Lucio Oliva 70:d20d30f59b1c 151 isInitialized = false;
Silvio Lucio Oliva 70:d20d30f59b1c 152
Silvio Lucio Oliva 70:d20d30f59b1c 153 return BLE_ERROR_NONE;
Silvio Lucio Oliva 70:d20d30f59b1c 154 }
Silvio Lucio Oliva 70:d20d30f59b1c 155
Silvio Lucio Oliva 70:d20d30f59b1c 156
Silvio Lucio Oliva 70:d20d30f59b1c 157 /*!
Silvio Lucio Oliva 70:d20d30f59b1c 158 @brief Wait for any BLE Event like BLE Connection, Read Request etc.
Silvio Lucio Oliva 70:d20d30f59b1c 159 @param[in] void
Silvio Lucio Oliva 70:d20d30f59b1c 160 @returns char *
Silvio Lucio Oliva 70:d20d30f59b1c 161 */
Silvio Lucio Oliva 70:d20d30f59b1c 162 void BlueNRGDevice::waitForEvent(void)
Silvio Lucio Oliva 70:d20d30f59b1c 163 {
Silvio Lucio Oliva 70:d20d30f59b1c 164 HCI_Process();//Send App Events??
Silvio Lucio Oliva 70:d20d30f59b1c 165
Silvio Lucio Oliva 70:d20d30f59b1c 166 }
Silvio Lucio Oliva 70:d20d30f59b1c 167
Silvio Lucio Oliva 70:d20d30f59b1c 168
Silvio Lucio Oliva 70:d20d30f59b1c 169 /*!
Silvio Lucio Oliva 70:d20d30f59b1c 170 @brief get GAP version
Silvio Lucio Oliva 70:d20d30f59b1c 171 @param[in] void
Silvio Lucio Oliva 70:d20d30f59b1c 172 @returns char *
Silvio Lucio Oliva 70:d20d30f59b1c 173 */
Silvio Lucio Oliva 70:d20d30f59b1c 174 const char *BlueNRGDevice::getVersion(void)
Silvio Lucio Oliva 70:d20d30f59b1c 175 {
Silvio Lucio Oliva 70:d20d30f59b1c 176 char *version = new char[6];
Silvio Lucio Oliva 70:d20d30f59b1c 177 memcpy((void *)version, "1.0.0", 5);
Silvio Lucio Oliva 70:d20d30f59b1c 178 return version;
Silvio Lucio Oliva 70:d20d30f59b1c 179 }
Silvio Lucio Oliva 70:d20d30f59b1c 180
Silvio Lucio Oliva 70:d20d30f59b1c 181 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 182 /*!
Silvio Lucio Oliva 70:d20d30f59b1c 183 @brief get init state
Silvio Lucio Oliva 70:d20d30f59b1c 184 @param[in] void
Silvio Lucio Oliva 70:d20d30f59b1c 185 @returns bool
Silvio Lucio Oliva 70:d20d30f59b1c 186 */
Silvio Lucio Oliva 70:d20d30f59b1c 187 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 188 bool BlueNRGDevice::getIsInitialized(void)
Silvio Lucio Oliva 70:d20d30f59b1c 189 {
Silvio Lucio Oliva 70:d20d30f59b1c 190 return isInitialized;
Silvio Lucio Oliva 70:d20d30f59b1c 191 }
Silvio Lucio Oliva 70:d20d30f59b1c 192
Silvio Lucio Oliva 70:d20d30f59b1c 193 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 194 /*!
Silvio Lucio Oliva 70:d20d30f59b1c 195 @brief get reference to GAP object
Silvio Lucio Oliva 70:d20d30f59b1c 196 @param[in] void
Silvio Lucio Oliva 70:d20d30f59b1c 197 @returns Gap&
Silvio Lucio Oliva 70:d20d30f59b1c 198 */
Silvio Lucio Oliva 70:d20d30f59b1c 199 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 200 Gap &BlueNRGDevice::getGap()
Silvio Lucio Oliva 70:d20d30f59b1c 201 {
Silvio Lucio Oliva 70:d20d30f59b1c 202 return BlueNRGGap::getInstance();
Silvio Lucio Oliva 70:d20d30f59b1c 203 }
Silvio Lucio Oliva 70:d20d30f59b1c 204
Silvio Lucio Oliva 70:d20d30f59b1c 205 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 206 /*!
Silvio Lucio Oliva 70:d20d30f59b1c 207 @brief get reference to GATT server object
Silvio Lucio Oliva 70:d20d30f59b1c 208 @param[in] void
Silvio Lucio Oliva 70:d20d30f59b1c 209 @returns GattServer&
Silvio Lucio Oliva 70:d20d30f59b1c 210 */
Silvio Lucio Oliva 70:d20d30f59b1c 211 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 212 GattServer &BlueNRGDevice::getGattServer()
Silvio Lucio Oliva 70:d20d30f59b1c 213 {
Silvio Lucio Oliva 70:d20d30f59b1c 214 return BlueNRGGattServer::getInstance();
Silvio Lucio Oliva 70:d20d30f59b1c 215 }
Silvio Lucio Oliva 70:d20d30f59b1c 216
Silvio Lucio Oliva 70:d20d30f59b1c 217 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 218 /*!
Silvio Lucio Oliva 70:d20d30f59b1c 219 @brief set Tx power level
Silvio Lucio Oliva 70:d20d30f59b1c 220 @param[in] txPower Transmission Power level
Silvio Lucio Oliva 70:d20d30f59b1c 221 @returns ble_error_t
Silvio Lucio Oliva 70:d20d30f59b1c 222 */
Silvio Lucio Oliva 70:d20d30f59b1c 223 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 224 ble_error_t BlueNRGDevice::setTxPower(int8_t txPower)
Silvio Lucio Oliva 70:d20d30f59b1c 225 {
Silvio Lucio Oliva 70:d20d30f59b1c 226 int8_t enHighPower = 0;
Silvio Lucio Oliva 70:d20d30f59b1c 227 int8_t paLevel = 0;
Silvio Lucio Oliva 70:d20d30f59b1c 228 int8_t dbmActuallySet = getHighPowerAndPALevelValue(txPower, enHighPower, paLevel);
Silvio Lucio Oliva 70:d20d30f59b1c 229 DEBUG("txPower=%d, dbmActuallySet=%d\n\r", txPower, dbmActuallySet);
Silvio Lucio Oliva 70:d20d30f59b1c 230 DEBUG("enHighPower=%d, paLevel=%d\n\r", enHighPower, paLevel);
Silvio Lucio Oliva 70:d20d30f59b1c 231 aci_hal_set_tx_power_level(enHighPower, paLevel);
Silvio Lucio Oliva 70:d20d30f59b1c 232 return BLE_ERROR_NONE;
Silvio Lucio Oliva 70:d20d30f59b1c 233 }
Silvio Lucio Oliva 70:d20d30f59b1c 234
Silvio Lucio Oliva 70:d20d30f59b1c 235 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 236 /*!
Silvio Lucio Oliva 70:d20d30f59b1c 237 @brief get permitted Tx power values
Silvio Lucio Oliva 70:d20d30f59b1c 238 @param[in] values pointer to pointer to permitted power values
Silvio Lucio Oliva 70:d20d30f59b1c 239 @param[in] num number of values
Silvio Lucio Oliva 70:d20d30f59b1c 240 */
Silvio Lucio Oliva 70:d20d30f59b1c 241 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 242 void BlueNRGDevice::getPermittedTxPowerValues(const int8_t **valueArrayPP, size_t *countP) {
Silvio Lucio Oliva 70:d20d30f59b1c 243 static const int8_t permittedTxValues[] = {
Silvio Lucio Oliva 70:d20d30f59b1c 244 -18, -14, -11, -8, -4, -1, 1, 5, -15, -11, -8, -5, -2, 1, 4, 8
Silvio Lucio Oliva 70:d20d30f59b1c 245 };
Silvio Lucio Oliva 70:d20d30f59b1c 246
Silvio Lucio Oliva 70:d20d30f59b1c 247 *valueArrayPP = permittedTxValues;
Silvio Lucio Oliva 70:d20d30f59b1c 248 *countP = sizeof(permittedTxValues) / sizeof(int8_t);
Silvio Lucio Oliva 70:d20d30f59b1c 249 }
Silvio Lucio Oliva 70:d20d30f59b1c 250
Silvio Lucio Oliva 70:d20d30f59b1c 251
Silvio Lucio Oliva 70:d20d30f59b1c 252 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 253 /*!
Silvio Lucio Oliva 70:d20d30f59b1c 254 @brief shut down the the BLE device
Silvio Lucio Oliva 70:d20d30f59b1c 255 @param[out] error if any
Silvio Lucio Oliva 70:d20d30f59b1c 256 */
Silvio Lucio Oliva 70:d20d30f59b1c 257 /**************************************************************************/
Silvio Lucio Oliva 70:d20d30f59b1c 258 ble_error_t BlueNRGDevice::shutdown(void) {
Silvio Lucio Oliva 70:d20d30f59b1c 259 return reset();
Silvio Lucio Oliva 70:d20d30f59b1c 260 }
Silvio Lucio Oliva 70:d20d30f59b1c 261
Silvio Lucio Oliva 70:d20d30f59b1c 262 // ANDREA
Silvio Lucio Oliva 70:d20d30f59b1c 263 ble_error_t BlueNRGDevice::initializeSecurity(bool enableBonding,
Silvio Lucio Oliva 70:d20d30f59b1c 264 bool requireMITM,
Silvio Lucio Oliva 70:d20d30f59b1c 265 Gap::SecurityIOCapabilities_t iocaps,
Silvio Lucio Oliva 70:d20d30f59b1c 266 const Gap::Passkey_t passkey) {
Silvio Lucio Oliva 70:d20d30f59b1c 267 // Empty by now
Silvio Lucio Oliva 70:d20d30f59b1c 268 return BLE_ERROR_NONE;
Silvio Lucio Oliva 70:d20d30f59b1c 269 }
Antonio Vilei 74:c4526f8284d5 270
Antonio Vilei 74:c4526f8284d5 271 /**
Antonio Vilei 74:c4526f8284d5 272 * @brief Reads from BlueNRG SPI buffer and store data into local buffer.
Antonio Vilei 74:c4526f8284d5 273 * @param buffer : Buffer where data from SPI are stored
Antonio Vilei 74:c4526f8284d5 274 * @param buff_size: Buffer size
Antonio Vilei 74:c4526f8284d5 275 * @retval int32_t : Number of read bytes
Antonio Vilei 74:c4526f8284d5 276 */
Antonio Vilei 74:c4526f8284d5 277 int32_t BlueNRGDevice::spiRead(uint8_t *buffer, uint8_t buff_size)
Antonio Vilei 74:c4526f8284d5 278 {
Antonio Vilei 74:c4526f8284d5 279 uint16_t byte_count;
Antonio Vilei 74:c4526f8284d5 280 uint8_t len = 0;
Antonio Vilei 74:c4526f8284d5 281 uint8_t char_ff = 0xff;
Antonio Vilei 74:c4526f8284d5 282 volatile uint8_t read_char;
Antonio Vilei 74:c4526f8284d5 283
Antonio Vilei 74:c4526f8284d5 284 uint8_t i = 0;
Antonio Vilei 74:c4526f8284d5 285 volatile uint8_t tmpreg;
Antonio Vilei 74:c4526f8284d5 286
Antonio Vilei 74:c4526f8284d5 287 uint8_t header_master[HEADER_SIZE] = {0x0b, 0x00, 0x00, 0x00, 0x00};
Antonio Vilei 74:c4526f8284d5 288 uint8_t header_slave[HEADER_SIZE];
Antonio Vilei 74:c4526f8284d5 289
Antonio Vilei 74:c4526f8284d5 290 /* Select the chip */
Antonio Vilei 74:c4526f8284d5 291 nCS_ = 0;
Antonio Vilei 74:c4526f8284d5 292
Antonio Vilei 74:c4526f8284d5 293 /* Read the header */
Antonio Vilei 74:c4526f8284d5 294 for (i = 0; i < 5; i++)
Antonio Vilei 74:c4526f8284d5 295 {
Antonio Vilei 74:c4526f8284d5 296 tmpreg = spi_.write(header_master[i]);
Antonio Vilei 74:c4526f8284d5 297 header_slave[i] = (uint8_t)(tmpreg);
Antonio Vilei 74:c4526f8284d5 298 }
Antonio Vilei 74:c4526f8284d5 299
Antonio Vilei 74:c4526f8284d5 300 if (header_slave[0] == 0x02) {
Antonio Vilei 74:c4526f8284d5 301 /* device is ready */
Antonio Vilei 74:c4526f8284d5 302 byte_count = (header_slave[4]<<8)|header_slave[3];
Antonio Vilei 74:c4526f8284d5 303
Antonio Vilei 74:c4526f8284d5 304 if (byte_count > 0) {
Antonio Vilei 74:c4526f8284d5 305
Antonio Vilei 74:c4526f8284d5 306 /* avoid to read more data that size of the buffer */
Antonio Vilei 74:c4526f8284d5 307 if (byte_count > buff_size){
Antonio Vilei 74:c4526f8284d5 308 byte_count = buff_size;
Antonio Vilei 74:c4526f8284d5 309 }
Antonio Vilei 74:c4526f8284d5 310
Antonio Vilei 74:c4526f8284d5 311 for (len = 0; len < byte_count; len++){
Antonio Vilei 74:c4526f8284d5 312 read_char = spi_.write(char_ff);
Antonio Vilei 74:c4526f8284d5 313 buffer[len] = read_char;
Antonio Vilei 74:c4526f8284d5 314 }
Antonio Vilei 74:c4526f8284d5 315 }
Antonio Vilei 74:c4526f8284d5 316 }
Antonio Vilei 74:c4526f8284d5 317 /* Release CS line to deselect the chip */
Antonio Vilei 74:c4526f8284d5 318 nCS_ = 1;
Antonio Vilei 74:c4526f8284d5 319
Antonio Vilei 74:c4526f8284d5 320 // Add a small delay to give time to the BlueNRG to set the IRQ pin low
Antonio Vilei 74:c4526f8284d5 321 // to avoid a useless SPI read at the end of the transaction
Antonio Vilei 74:c4526f8284d5 322 for(volatile int i = 0; i < 2; i++)__NOP();
Antonio Vilei 74:c4526f8284d5 323
Antonio Vilei 74:c4526f8284d5 324 #ifdef PRINT_CSV_FORMAT
Antonio Vilei 74:c4526f8284d5 325 if (len > 0) {
Antonio Vilei 74:c4526f8284d5 326 // print_csv_time();
Antonio Vilei 74:c4526f8284d5 327 for (int i=0; i<len; i++) {
Antonio Vilei 74:c4526f8284d5 328 PRINT_CSV(" %02x", buffer[i]);
Antonio Vilei 74:c4526f8284d5 329 }
Antonio Vilei 74:c4526f8284d5 330 PRINT_CSV("\n");
Antonio Vilei 74:c4526f8284d5 331 }
Antonio Vilei 74:c4526f8284d5 332 #endif
Antonio Vilei 74:c4526f8284d5 333
Antonio Vilei 74:c4526f8284d5 334 return len;
Antonio Vilei 74:c4526f8284d5 335 }
Antonio Vilei 74:c4526f8284d5 336
Antonio Vilei 74:c4526f8284d5 337 /**
Antonio Vilei 74:c4526f8284d5 338 * @brief Writes data from local buffer to SPI.
Antonio Vilei 74:c4526f8284d5 339 * @param data1 : First data buffer to be written
Antonio Vilei 74:c4526f8284d5 340 * @param data2 : Second data buffer to be written
Antonio Vilei 74:c4526f8284d5 341 * @param Nb_bytes1: Size of first data buffer to be written
Antonio Vilei 74:c4526f8284d5 342 * @param Nb_bytes2: Size of second data buffer to be written
Antonio Vilei 74:c4526f8284d5 343 * @retval Number of read bytes
Antonio Vilei 74:c4526f8284d5 344 */
Antonio Vilei 74:c4526f8284d5 345 int32_t BlueNRGDevice::spiWrite(uint8_t* data1,
Antonio Vilei 74:c4526f8284d5 346 uint8_t* data2, uint8_t Nb_bytes1, uint8_t Nb_bytes2)
Antonio Vilei 74:c4526f8284d5 347 {
Antonio Vilei 74:c4526f8284d5 348 int32_t result = 0;
Antonio Vilei 74:c4526f8284d5 349
Antonio Vilei 74:c4526f8284d5 350 uint32_t i;
Antonio Vilei 74:c4526f8284d5 351 volatile uint8_t read_char;
Antonio Vilei 74:c4526f8284d5 352 volatile uint8_t tmpreg;
Antonio Vilei 74:c4526f8284d5 353
Antonio Vilei 74:c4526f8284d5 354 unsigned char header_master[HEADER_SIZE] = {0x0a, 0x00, 0x00, 0x00, 0x00};
Antonio Vilei 74:c4526f8284d5 355 unsigned char header_slave[HEADER_SIZE] = {0xaa, 0x00, 0x00, 0x00, 0x00};
Antonio Vilei 74:c4526f8284d5 356
Antonio Vilei 74:c4526f8284d5 357 unsigned char read_char_buf[MAX_BUFFER_SIZE];
Antonio Vilei 74:c4526f8284d5 358
Antonio Vilei 74:c4526f8284d5 359 disable_irq();
Antonio Vilei 74:c4526f8284d5 360
Antonio Vilei 74:c4526f8284d5 361 /* CS reset */
Antonio Vilei 74:c4526f8284d5 362 nCS_ = 0;
Antonio Vilei 74:c4526f8284d5 363
Antonio Vilei 74:c4526f8284d5 364 /* Exchange header */
Antonio Vilei 74:c4526f8284d5 365 for (i = 0; i < 5; i++)
Antonio Vilei 74:c4526f8284d5 366 {
Antonio Vilei 74:c4526f8284d5 367 tmpreg = spi_.write(header_master[i]);
Antonio Vilei 74:c4526f8284d5 368 header_slave[i] = tmpreg;
Antonio Vilei 74:c4526f8284d5 369 }
Antonio Vilei 74:c4526f8284d5 370
Antonio Vilei 74:c4526f8284d5 371 if (header_slave[0] == 0x02) {
Antonio Vilei 74:c4526f8284d5 372 /* SPI is ready */
Antonio Vilei 74:c4526f8284d5 373 if (header_slave[1] >= (Nb_bytes1+Nb_bytes2)) {
Antonio Vilei 74:c4526f8284d5 374
Antonio Vilei 74:c4526f8284d5 375 /* Buffer is big enough */
Antonio Vilei 74:c4526f8284d5 376 for (i = 0; i < Nb_bytes1; i++) {
Antonio Vilei 74:c4526f8284d5 377 read_char = spi_.write(*(data1 + i));
Antonio Vilei 74:c4526f8284d5 378 }
Antonio Vilei 74:c4526f8284d5 379 for (i = 0; i < Nb_bytes2; i++) {
Antonio Vilei 74:c4526f8284d5 380 read_char = spi_.write(*(data2 + i));
Antonio Vilei 74:c4526f8284d5 381 }
Antonio Vilei 74:c4526f8284d5 382 } else {
Antonio Vilei 74:c4526f8284d5 383 /* Buffer is too small */
Antonio Vilei 74:c4526f8284d5 384 result = -2;
Antonio Vilei 74:c4526f8284d5 385 }
Antonio Vilei 74:c4526f8284d5 386 } else {
Antonio Vilei 74:c4526f8284d5 387 /* SPI is not ready */
Antonio Vilei 74:c4526f8284d5 388 result = -1;
Antonio Vilei 74:c4526f8284d5 389 }
Antonio Vilei 74:c4526f8284d5 390
Antonio Vilei 74:c4526f8284d5 391 /* Release CS line */
Antonio Vilei 74:c4526f8284d5 392 //HAL_GPIO_WritePin(BNRG_SPI_CS_PORT, BNRG_SPI_CS_PIN, GPIO_PIN_SET);
Antonio Vilei 74:c4526f8284d5 393 nCS_ = 1;
Antonio Vilei 74:c4526f8284d5 394
Antonio Vilei 74:c4526f8284d5 395 enable_irq();
Antonio Vilei 74:c4526f8284d5 396
Antonio Vilei 74:c4526f8284d5 397 return result;
Antonio Vilei 74:c4526f8284d5 398 }
Antonio Vilei 74:c4526f8284d5 399
Antonio Vilei 74:c4526f8284d5 400 bool BlueNRGDevice::dataPresent()
Antonio Vilei 74:c4526f8284d5 401 {
Antonio Vilei 74:c4526f8284d5 402 return (irq_ == 1);
Antonio Vilei 74:c4526f8284d5 403 }
Antonio Vilei 74:c4526f8284d5 404
Antonio Vilei 74:c4526f8284d5 405 void BlueNRGDevice::disable_irq()
Antonio Vilei 74:c4526f8284d5 406 {
Antonio Vilei 74:c4526f8284d5 407 irq_.disable_irq();
Antonio Vilei 74:c4526f8284d5 408 }
Antonio Vilei 74:c4526f8284d5 409
Antonio Vilei 74:c4526f8284d5 410 void BlueNRGDevice::enable_irq()
Antonio Vilei 74:c4526f8284d5 411 {
Antonio Vilei 74:c4526f8284d5 412 irq_.enable_irq();
Antonio Vilei 74:c4526f8284d5 413 }