{

switch(event){

case CONN_COMPLETE: return F("CONN_COMPLETE");

case ADVERTISING_REPORT: return F("ADVERTISING_REPORT");

case LONG_TERM_KEY_REQUEST: return F("LE_LONG_TERM_KEY_REQUEST");

case READ_LOCAL_P256_COMPLETE: return F("READ_LOCAL_P256_COMPLETE");

case GENERATE_DH_KEY_COMPLETE: return F("GENERATE_DH_KEY_COMPLETE");

case ENHANCED_CONN_COMPLETE: return F("ENHANCED_CONN_COMPLETE");

default: return "event unknown";

}

switch (command)

{

case ENCRYPT: return F("ENCRYPT");

case LONG_TERM_KEY_REPLY: return F("LONG_TERM_KEY_REPLY");

case READ_LOCAL_P256: return F("READ_LOCAL_P256");

case GENERATE_DH_KEY_V1: return F("GENERATE_DH_KEY_V1");

case GENERATE_DH_KEY_V2: return F("GENERATE_DH_KEY_V2");

default: return "UNKNOWN";

}

_debug(NULL),

_recvIndex(0),

_pendingPkt(0),

_l2CapPduBufferSize(0)

{

{

_recvIndex = 0;

return HCITransport.begin();

{

#ifdef ARDUINO_AVR_UNO_WIFI_REV2

digitalWrite(NINA_RTS, LOW);

#endif

if (timeout) {

HCITransport.wait(timeout);

}

HCITransport.lockForRead();

while (HCITransport.available()) {

byte b = HCITransport.read();

if (_recvIndex >= (int)sizeof(_recvBuffer)) {

_recvIndex = 0;

if (_debug) {

HCITransport.unlockForRead();

_debug->println("_recvBuffer overflow");

HCITransport.lockForRead();

}

}

_recvBuffer[_recvIndex++] = b;

if (_recvBuffer[0] == HCI_ACLDATA_PKT) {

if (_recvIndex > 5 && _recvIndex >= (5 + (_recvBuffer[3] + (_recvBuffer[4] << 8)))) {

HCITransport.unlockForRead();

if (_debug) {

dumpPkt("HCI ACLDATA RX <- ", _recvIndex, _recvBuffer);

}

#ifdef ARDUINO_AVR_UNO_WIFI_REV2

digitalWrite(NINA_RTS, HIGH);

#endif

int pktLen = _recvIndex - 1;

_recvIndex = 0;

handleAclDataPkt(pktLen, &_recvBuffer[1]);

#ifdef ARDUINO_AVR_UNO_WIFI_REV2

digitalWrite(NINA_RTS, LOW);

#endif

HCITransport.lockForRead();

}

} else if (_recvBuffer[0] == HCI_EVENT_PKT) {

if (_recvIndex > 3 && _recvIndex >= (3 + _recvBuffer[2])) {

HCITransport.unlockForRead();

if (_debug) {

dumpPkt("HCI EVENT RX <- ", _recvIndex, _recvBuffer);

}

#ifdef ARDUINO_AVR_UNO_WIFI_REV2

digitalWrite(NINA_RTS, HIGH);

#endif

// received full event

int pktLen = _recvIndex - 1;

_recvIndex = 0;

handleEventPkt(pktLen, &_recvBuffer[1]);

#ifdef ARDUINO_AVR_UNO_WIFI_REV2

digitalWrite(NINA_RTS, LOW);

#endif

HCITransport.lockForRead();

}

} else {

_recvIndex = 0;

if (_debug) {

HCITransport.unlockForRead();

_debug->println(b, HEX);

HCITransport.lockForRead();

}

}

}

#ifdef ARDUINO_AVR_UNO_WIFI_REV2

digitalWrite(NINA_RTS, HIGH);

#endif

HCITransport.unlockForRead();

{

int result = sendCommand(OGF_INFO_PARAM << 10 | OCF_READ_LOCAL_VERSION);

if (result == 0) {

struct __attribute__ ((packed)) HCILocalVersion {

uint8_t hciVer;

uint16_t hciRev;

uint8_t lmpVer;

uint16_t manufacturer;

uint16_t lmpSubVer;

} *localVersion = (HCILocalVersion*)_cmdResponse;

hciVer = localVersion->hciVer;

hciRev = localVersion->hciRev;

lmpVer = localVersion->lmpVer;

manufacturer = localVersion->manufacturer;

lmpSubVer = localVersion->lmpSubVer;

}

return result;

{

int result = sendCommand(OGF_INFO_PARAM << 10 | OCF_READ_BD_ADDR);

if (result == 0) {

memcpy(addr, _cmdResponse, 6);

}

return result;

uint8_t response[6];

int result = readBdAddr(response);

if(result==0){

for(int i=0; i<6; i++){

localAddr[5-i] = _cmdResponse[i];

}

}

return result;

{

int result = sendCommand(OGF_STATUS_PARAM << 10 | OCF_READ_RSSI, sizeof(handle), &handle);

int rssi = 127;

if (result == 0) {

struct __attribute__ ((packed)) HCIReadRssi {

uint16_t handle;

int8_t rssi;

} *readRssi = (HCIReadRssi*)_cmdResponse;

if (readRssi->handle == handle) {

rssi = readRssi->rssi;

}

}

return rssi;

{

int result = sendCommand(OGF_LE_CTL << 10 | OCF_LE_READ_BUFFER_SIZE);

if (result == 0) {

struct __attribute__ ((packed)) HCILeBufferSize {

uint16_t pktLen;

uint8_t maxPkt;

} *leBufferSize = (HCILeBufferSize*)_cmdResponse;

pktLen = leBufferSize->pktLen;

_maxPkt = maxPkt = leBufferSize->maxPkt;

#ifndef __AVR__

ATT.setMaxMtu(pktLen - 9); // max pkt len - ACL header size

#endif

}

return result;

uint8_t advType, uint8_t ownBdaddrType,

uint8_t directBdaddrType, uint8_t directBdaddr[6],

uint8_t chanMap,

uint8_t filter)

{

struct __attribute__ ((packed)) HCILeAdvertisingParameters {

uint16_t minInterval;

uint16_t maxInterval;

uint8_t advType;

uint8_t ownBdaddrType;

uint8_t directBdaddrType;

uint8_t directBdaddr[6];

uint8_t chanMap;

uint8_t filter;

} leAdvertisingParamters;

leAdvertisingParamters.minInterval = minInterval;

leAdvertisingParamters.maxInterval = maxInterval;

leAdvertisingParamters.advType = advType;

leAdvertisingParamters.ownBdaddrType = ownBdaddrType;

leAdvertisingParamters.directBdaddrType = directBdaddrType;

memcpy(leAdvertisingParamters.directBdaddr, directBdaddr, 6);

leAdvertisingParamters.chanMap = chanMap;

leAdvertisingParamters.filter = filter;

return sendCommand(OGF_LE_CTL << 10 | OCF_LE_SET_ADVERTISING_PARAMETERS, sizeof(leAdvertisingParamters), &leAdvertisingParamters);

{

struct __attribute__ ((packed)) HCILeAdvertisingData {

uint8_t length;

uint8_t data[31];

} leAdvertisingData;

memset(&leAdvertisingData, 0, sizeof(leAdvertisingData));

leAdvertisingData.length = length;

memcpy(leAdvertisingData.data, data, length);

return sendCommand(OGF_LE_CTL << 10 | OCF_LE_SET_ADVERTISING_DATA, sizeof(leAdvertisingData), &leAdvertisingData);

{

struct __attribute__ ((packed)) HCILeScanResponseData {

uint8_t length;

uint8_t data[31];

} leScanResponseData;

memset(&leScanResponseData, 0, sizeof(leScanResponseData));

leScanResponseData.length = length;

memcpy(leScanResponseData.data, data, length);

return sendCommand(OGF_LE_CTL << 10 | OCF_LE_SET_SCAN_RESPONSE_DATA, sizeof(leScanResponseData), &leScanResponseData);

uint8_t ownBdaddrType, uint8_t filter)

{

struct __attribute__ ((packed)) HCILeSetScanParameters {

uint8_t type;

uint16_t interval;

uint16_t window;

uint8_t ownBdaddrType;

uint8_t filter;

} leScanParameters;

leScanParameters.type = type;

leScanParameters.interval = interval;

leScanParameters.window = window;

leScanParameters.ownBdaddrType = ownBdaddrType;

leScanParameters.filter = filter;

return sendCommand(OGF_LE_CTL << 10 | OCF_LE_SET_SCAN_PARAMETERS, sizeof(leScanParameters), &leScanParameters);

{

struct __attribute__ ((packed)) HCILeSetScanEnableData {

uint8_t enabled;

uint8_t duplicates;

} leScanEnableData;

leScanEnableData.enabled = enabled;

leScanEnableData.duplicates = duplicates;

return sendCommand(OGF_LE_CTL << 10 | OCF_LE_SET_SCAN_ENABLE, sizeof(leScanEnableData), &leScanEnableData);

uint8_t peerBdaddrType, uint8_t peerBdaddr[6], uint8_t ownBdaddrType,

uint16_t minInterval, uint16_t maxInterval, uint16_t latency,

uint16_t supervisionTimeout, uint16_t minCeLength, uint16_t maxCeLength)

{

struct __attribute__ ((packed)) HCILeCreateConnData {

uint16_t interval;

uint16_t window;

uint8_t initiatorFilter;

uint8_t peerBdaddrType;

uint8_t peerBdaddr[6];

uint8_t ownBdaddrType;

uint16_t minInterval;

uint16_t maxInterval;

uint16_t latency;

uint16_t supervisionTimeout;

uint16_t minCeLength;

uint16_t maxCeLength;

} leCreateConnData;

leCreateConnData.interval = interval;

leCreateConnData.window = window;

leCreateConnData.initiatorFilter = initiatorFilter;

leCreateConnData.peerBdaddrType = peerBdaddrType;

memcpy(leCreateConnData.peerBdaddr, peerBdaddr, sizeof(leCreateConnData.peerBdaddr));

leCreateConnData.ownBdaddrType = ownBdaddrType;

leCreateConnData.minInterval = minInterval;

leCreateConnData.maxInterval = maxInterval;

leCreateConnData.latency = latency;

leCreateConnData.supervisionTimeout = supervisionTimeout;

leCreateConnData.minCeLength = minCeLength;

leCreateConnData.maxCeLength = maxCeLength;

return sendCommand(OGF_LE_CTL << 10 | OCF_LE_CREATE_CONN, sizeof(leCreateConnData), &leCreateConnData);

uint16_t latency, uint16_t supervisionTimeout)

{

struct __attribute__ ((packed)) HCILeConnUpdateData {

uint16_t handle;

uint16_t minInterval;

uint16_t maxInterval;

uint16_t latency;

uint16_t supervisionTimeout;

uint16_t minCeLength;

uint16_t maxCeLength;

} leConnUpdateData;

leConnUpdateData.handle = handle;

leConnUpdateData.minInterval = minInterval;

leConnUpdateData.maxInterval = maxInterval;

leConnUpdateData.latency = latency;

leConnUpdateData.supervisionTimeout = supervisionTimeout;

leConnUpdateData.minCeLength = 0x0004;

leConnUpdateData.maxCeLength = 0x0006;

return sendCommand(OGF_LE_CTL << 10 | OCF_LE_CONN_UPDATE, sizeof(leConnUpdateData), &leConnUpdateData);

(void)addressType;

(void)localIrk;

if(_storeIRK!=0){

_storeIRK(address, peerIrk);

}

// Again... this should work

// leAddResolvingAddress(addressType, address, peerIrk, localIrk);

leStopResolvingAddresses();

struct __attribute__ ((packed)) AddDevice {

uint8_t peerAddressType;

uint8_t peerAddress[6];

uint8_t peerIRK[16];

uint8_t localIRK[16];

} addDevice;

addDevice.peerAddressType = addressType;

for(int i=0; i<6; i++) addDevice.peerAddress[5-i] = peerAddress[i];

for(int i=0; i<16; i++) {

addDevice.peerIRK[15-i] = peerIrk[i];

addDevice.localIRK[15-i] = localIrk[i];

}

#ifdef _BLE_TRACE_

Serial.print("ADDTYPE :");

btct.printBytes(&addDevice.peerAddressType,1);

Serial.print("adddddd :");

btct.printBytes(addDevice.peerAddress,6);

Serial.print("Peer IRK :");

btct.printBytes(addDevice.peerIRK,16);

Serial.print("localIRK :");

btct.printBytes(addDevice.localIRK,16);

#endif

sendCommand(OGF_LE_CTL << 10 | 0x27, sizeof(addDevice), &addDevice);

leStartResolvingAddresses();

(void)peerResolvableAddress;

struct __attribute__ ((packed)) Request {

uint8_t addressType;

uint8_t identityAddress[6];

} request;

request.addressType = peerAddressType;

for(int i=0; i<6; i++) request.identityAddress[5-i] = peerIdentityAddress[i];

int res = sendCommand(OGF_LE_CTL << 10 | 0x2B, sizeof(request), &request);

#ifdef _BLE_TRACE_

Serial.print("res: 0x");

Serial.println(res, HEX);

if(res==0){

struct __attribute__ ((packed)) Response {

uint8_t status;

uint8_t peerResolvableAddress[6];

} *response = (Response*)_cmdResponse;

Serial.print("Address resolution status: 0x");

Serial.println(response->status, HEX);

Serial.print("peer resolvable address: ");

btct.printBytes(response->peerResolvableAddress,6);

}

#endif

return res;

struct __attribute__ ((packed)) StoreLK {

uint8_t nKeys;

uint8_t BD_ADDR[6];

uint8_t LTK[16];

} storeLK;

storeLK.nKeys = 1;

memcpy(storeLK.BD_ADDR, peerAddress, 6);

for(int i=0; i<16; i++) storeLK.LTK[15-i] = LK[i];

HCI.sendCommand(OGF_HOST_CTL << 10 | 0x11, sizeof(storeLK), &storeLK);

struct __attribute__ ((packed)) Request {

uint8_t BD_ADDR[6];

uint8_t read_a;

} request = {{0},0};

for(int i=0; i<6; i++) request.BD_ADDR[5-i] = BD_ADDR[i];

request.read_a = read_all;

return sendCommand(OGF_HOST_CTL << 10 | 0xD, sizeof(request), &request);

bool foundMatch = false;

if(HCI._getIRKs!=0){

uint8_t nIRKs = 0;

uint8_t** BDAddrType = new uint8_t*;

uint8_t*** BADDRs = new uint8_t**;

uint8_t*** IRKs = new uint8_t**;

if(!HCI._getIRKs(&nIRKs, BDAddrType, BADDRs, IRKs)){

#ifdef _BLE_TRACE_

Serial.println("error getting IRKs.");

#endif

}

for(int i=0; i<nIRKs; i++){

if(!foundMatch){

#ifdef _BLE_TRACE_

Serial.print("BDAddr type: : 0x");

Serial.println((*BDAddrType)[i],HEX);

Serial.print("BDAddr : ");

btct.printBytes((*BADDRs)[i],6);

Serial.print("IRK : ");

btct.printBytes((*IRKs)[i],16);

#endif

uint8_t hashresult[3];

btct.ah((*IRKs)[i], BDAddr, hashresult);

#ifdef _BLE_TRACE_

Serial.print("hash match : ");

btct.printBytes(hashresult,3);

Serial.print(" : ");

btct.printBytes(&BDAddr[3],3);

#endif

for(int k=0; k<3; k++){

if(hashresult[k] == BDAddr[3 + k]){

foundMatch = true;

}else{

foundMatch = false;

break;

}

}

if(foundMatch){

memcpy(address, (*BADDRs)[i],6);

}

}

delete[] (*BADDRs)[i];

delete[] (*IRKs)[i];

}

delete[] (*BDAddrType);

delete BDAddrType;

delete[] (*BADDRs);

delete BADDRs;

delete[] (*IRKs);

delete IRKs;

if(foundMatch){

return 1;

}

}

return 0;

}

int HCIClass::sendAclPkt(uint16_t handle, uint8_t cid, uint8_t plen, void* data)

{

while (_pendingPkt >= _maxPkt) {

poll();

}

struct __attribute__ ((packed)) HCIACLHdr {

uint8_t pktType;

uint16_t handle;

uint16_t dlen;

uint16_t plen;

uint16_t cid;

} aclHdr = { HCI_ACLDATA_PKT, handle, uint8_t(plen + 4), plen, cid };

uint8_t txBuffer[sizeof(aclHdr) + plen];

memcpy(txBuffer, &aclHdr, sizeof(aclHdr));

memcpy(&txBuffer[sizeof(aclHdr)], data, plen);

if (_debug) {

dumpPkt("HCI ACLDATA TX -> ", sizeof(aclHdr) + plen, txBuffer);

}

#ifdef _BLE_TRACE_

Serial.print("Data tx -> ");

for(int i=0; i< sizeof(aclHdr) + plen;i++){

Serial.print(" 0x");

Serial.print(txBuffer[i],HEX);

}

Serial.println(".");

#endif

_pendingPkt++;

HCITransport.write(txBuffer, sizeof(aclHdr) + plen);

return 0;

}

int HCIClass::disconnect(uint16_t handle)

{

struct __attribute__ ((packed)) HCIDisconnectData {

uint16_t handle;

uint8_t reason;

} disconnectData = { handle, HCI_OE_USER_ENDED_CONNECTION };

return sendCommand(OGF_LINK_CTL << 10 | OCF_DISCONNECT, sizeof(disconnectData), &disconnectData);

}

void HCIClass::debug(Stream& stream)

{

_debug = &stream;

}

void HCIClass::noDebug()

{

_debug = NULL;

}

int HCIClass::sendCommand(uint16_t opcode, uint8_t plen, void* parameters)

{

struct __attribute__ ((packed)) {

uint8_t pktType;

uint16_t opcode;

uint8_t plen;

} pktHdr = {HCI_COMMAND_PKT, opcode, plen};

uint8_t txBuffer[sizeof(pktHdr) + plen];

memcpy(txBuffer, &pktHdr, sizeof(pktHdr));

memcpy(&txBuffer[sizeof(pktHdr)], parameters, plen);

if (_debug) {

dumpPkt("HCI COMMAND TX -> ", sizeof(pktHdr) + plen, txBuffer);

}

#ifdef _BLE_TRACE_

Serial.print("Command tx -> ");

for(int i=0; i< sizeof(pktHdr) + plen;i++){

Serial.print(" 0x");

Serial.print(txBuffer[i],HEX);

}

Serial.println("");

#endif

HCITransport.write(txBuffer, sizeof(pktHdr) + plen);

_cmdCompleteOpcode = 0xffff;

_cmdCompleteStatus = -1;

for (unsigned long start = millis(); _cmdCompleteOpcode != opcode && millis() < (start + 1000);) {

poll();

}

return _cmdCompleteStatus;

}

void HCIClass::handleAclDataPkt(uint8_t /*plen*/, uint8_t pdata[])

{

struct __attribute__ ((packed)) HCIACLHdr {

uint16_t connectionHandleWithFlags;

uint16_t dlen; // dlen + 4 = plen (dlen is the size of the ACL SDU)

} *aclHeader = (HCIACLHdr*)pdata;

uint8_t pbFlag = (aclHeader->connectionHandleWithFlags & 0x3000) >> 12;

uint16_t connectionHandle = aclHeader->connectionHandleWithFlags & 0x0fff;

uint8_t *aclSdu = &pdata[sizeof(HCIACLHdr)];

#ifdef _BLE_TRACE_

uint8_t bcFlag = (aclHeader->connectionHandleWithFlags & 0xc000) >> 14;

Serial.print("Acl packet bcFlag = ");

Serial.print(bcFlag, BIN);

Serial.print(" pbFlag = ");

Serial.print(pbFlag, BIN);

Serial.print(" connectionHandle = ");

Serial.print(connectionHandle, HEX);

Serial.print(" dlen = ");

Serial.println(aclHeader->dlen, DEC);

#endif

// Pointer to the L2CAP PDU (might be reconstructed from multiple fragments)

uint8_t *l2CapPdu;

uint8_t l2CapPduSize;

if (pbFlag == 0b10) {

// "First automatically flushable packet" = Start of our L2CAP PDU

l2CapPdu = aclSdu;

l2CapPduSize = aclHeader->dlen;

} else if (pbFlag == 0b01) {

// "Continuing Fragment" = Continued L2CAP PDU

#ifdef _BLE_TRACE_

Serial.print("Continued packet. Appending to L2CAP PDU buffer (previously ");

Serial.print(_l2CapPduBufferSize, DEC);

Serial.println(" bytes in buffer)");

#endif

// If we receive a fragment, we always need to append it to the L2CAP PDU buffer

memcpy(&_l2CapPduBuffer[_l2CapPduBufferSize], aclSdu, aclHeader->dlen);

_l2CapPduBufferSize += aclHeader->dlen;

l2CapPdu = _l2CapPduBuffer;

l2CapPduSize = _l2CapPduBufferSize;

} else {

// I don't think other values are allowed for BLE

#ifdef _BLE_TRACE_

Serial.println("Invalid pbFlag, discarding packet");

#endif

return;

}

// We now have a valid L2CAP header in l2CapPdu and can parse the headers

struct __attribute__ ((packed)) HCIL2CapHdr {

uint16_t len; // size of the L2CAP SDU

uint16_t cid;

} *l2CapHeader = (HCIL2CapHdr*)l2CapPdu;

#ifdef _BLE_TRACE_

Serial.print("Received ");

Serial.print(l2CapPduSize - 4, DEC);

Serial.print("B/");

Serial.print(l2CapHeader->len, DEC);

Serial.print("B of the L2CAP SDU. CID = ");

Serial.println(l2CapHeader->cid, HEX);

#endif

// -4 because the buffer is the L2CAP PDU (with L2CAP header). The len field is only the L2CAP SDU (without L2CAP header).

if (l2CapPduSize - 4 != l2CapHeader->len) {

#ifdef _BLE_TRACE_

Serial.println("L2CAP SDU incomplete");

#endif

// If this is a first packet, we have not copied it into the buffer yet

if (pbFlag == 0b10) {

#ifdef _BLE_TRACE_

Serial.println("Storing first packet to L2CAP PDU buffer");

if (_l2CapPduBufferSize != 0) {

Serial.print("Warning: Discarding ");

Serial.print(_l2CapPduBufferSize, DEC);

Serial.println(" bytes from buffer");

}

#endif

memcpy(_l2CapPduBuffer, l2CapPdu, l2CapPduSize);

_l2CapPduBufferSize = l2CapPduSize;

}

// We need to wait for the missing parts of the L2CAP SDU

return;

}

#ifdef _BLE_TRACE_

Serial.println("L2CAP SDU complete");

#endif

if (l2CapHeader->cid == ATT_CID) {

#ifdef _BLE_TRACE_

Serial.println("CID: ATT");

#endif

ATT.handleData(connectionHandle, l2CapHeader->len, &l2CapPdu[sizeof(HCIL2CapHdr)]);

} else if (l2CapHeader->cid == SIGNALING_CID) {

#ifdef _BLE_TRACE_

Serial.println("CID: SIGNALING");

#endif

L2CAPSignaling.handleData(connectionHandle, l2CapHeader->len, &l2CapPdu[sizeof(HCIL2CapHdr)]);

} else if (l2CapHeader->cid == SECURITY_CID) {

// Security manager

#ifdef _BLE_TRACE_

Serial.println("CID: SECURITY");

#endif

L2CAPSignaling.handleSecurityData(connectionHandle, l2CapHeader->len, &l2CapPdu[sizeof(HCIL2CapHdr)]);

} else {

struct __attribute__ ((packed)) {

uint8_t op;

uint8_t id;

uint16_t length;

uint16_t reason;

uint16_t localCid;

uint16_t remoteCid;

} l2capRejectCid= { 0x01, 0x00, 0x006, 0x0002, l2CapHeader->cid, 0x0000 };

#ifdef _BLE_TRACE_

Serial.println("Rejecting packet cid");

#endif

sendAclPkt(connectionHandle, 0x0005, sizeof(l2capRejectCid), &l2capRejectCid);

}

// We have processed everything in the buffer. Discard the contents.

_l2CapPduBufferSize = 0;

}

void HCIClass::handleNumCompPkts(uint16_t /*handle*/, uint16_t numPkts)

{

if (numPkts && _pendingPkt > numPkts) {

_pendingPkt -= numPkts;

} else {

_pendingPkt = 0;

}

}

void HCIClass::handleEventPkt(uint8_t /*plen*/, uint8_t pdata[])

{

struct __attribute__ ((packed)) HCIEventHdr {

uint8_t evt;

uint8_t plen;

} *eventHdr = (HCIEventHdr*)pdata;

#ifdef _BLE_TRACE_

Serial.print("HCI event: ");

Serial.println(eventHdr->evt, HEX);

#endif

if (eventHdr->evt == EVT_DISCONN_COMPLETE)

{

struct __attribute__ ((packed)) DisconnComplete {

uint8_t status;

uint16_t handle;

uint8_t reason;

} *disconnComplete = (DisconnComplete*)&pdata[sizeof(HCIEventHdr)];

ATT.removeConnection(disconnComplete->handle, disconnComplete->reason);

L2CAPSignaling.removeConnection(disconnComplete->handle, disconnComplete->reason);

if (GAP.advertising())

{

HCI.leSetAdvertiseEnable(0x01);

}

}

else if (eventHdr->evt == EVT_ENCRYPTION_CHANGE)

{

struct __attribute__ ((packed)) EncryptionChange {

uint8_t status;

uint16_t connectionHandle;

uint8_t enabled;

} *encryptionChange = (EncryptionChange*)&pdata[sizeof(HCIEventHdr)];

#ifdef _BLE_TRACE_

Serial.println("[Info] Encryption changed");

Serial.print("status : ");

btct.printBytes(&encryptionChange->status,1);

Serial.print("handle : ");

btct.printBytes((uint8_t*)&encryptionChange->connectionHandle,2);

Serial.print("enabled: ");

btct.printBytes(&encryptionChange->enabled,1);

#endif

if(encryptionChange->enabled>0){

// 0001 1110

if((ATT.getPeerEncryption(encryptionChange->connectionHandle)&PEER_ENCRYPTION::PAIRING_REQUEST)>0){

if(ATT.localKeyDistribution.EncKey()){

#ifdef _BLE_TRACE_

Serial.println("Enc key set but should be ignored");

#endif

}else{

#ifdef _BLE_TRACE_

Serial.println("No enc key distribution");

#endif

}

// From page 1681 bluetooth standard - order matters

if(ATT.localKeyDistribution.IdKey()){

/// We shall distribute IRK and address using identity information

{

uint8_t response[17];

response[0] = CONNECTION_IDENTITY_INFORMATION; // Identity information.

for(int i=0; i<16; i++) response[16-i] = ATT.localIRK[i];

HCI.sendAclPkt(encryptionChange->connectionHandle, SECURITY_CID, sizeof(response), response);

#ifdef _BLE_TRACE_

Serial.println("Distribute ID Key");

#endif

}

{

uint8_t response[8];

response[0] = CONNECTION_IDENTITY_ADDRESS; // Identity address information

response[1] = 0x00; // Static local address

for(int i=0; i<6; i++) response[7-i] = HCI.localAddr[i];

HCI.sendAclPkt(encryptionChange->connectionHandle, SECURITY_CID, sizeof(response), response);

}

}

if(ATT.localKeyDistribution.SignKey()){

/// We shall distribut CSRK

#ifdef _BLE_TRACE_

Serial.println("We shall distribute CSRK // not implemented");

#endif

}else{

// Serial.println("We don't want to distribute CSRK");

}

if(ATT.localKeyDistribution.LinkKey()){

#ifdef _BLE_TRACE_

Serial.println("We would like to use LTK to generate BR/EDR // not implemented");

#endif

}

}else{

#ifdef _BLE_TRACE_

Serial.println("Reconnection, not pairing so no keys");

Serial.println(ATT.getPeerEncryption(encryptionChange->connectionHandle),HEX);

#endif

}

ATT.setPeerEncryption(encryptionChange->connectionHandle, PEER_ENCRYPTION::ENCRYPTED_AES);

if(ATT.writeBufferSize > 0){

ATT.processWriteBuffer();

}

if(ATT.holdBufferSize>0){

#ifdef _BLE_TRACE_

Serial.print("Sending queued response size: ");

Serial.println(ATT.holdBufferSize);

#endif

HCI.sendAclPkt(encryptionChange->connectionHandle, ATT_CID, ATT.holdBufferSize, ATT.holdBuffer);

ATT.holdBufferSize = 0;

}

}else{

ATT.setPeerEncryption(encryptionChange->connectionHandle, PEER_ENCRYPTION::NO_ENCRYPTION);

}

}

else if (eventHdr->evt == EVT_CMD_COMPLETE)

{

struct __attribute__ ((packed)) CmdComplete {

uint8_t ncmd;

uint16_t opcode;

uint8_t status;

} *cmdCompleteHeader = (CmdComplete*)&pdata[sizeof(HCIEventHdr)];

#ifdef _BLE_TRACE_

Serial.print("E ncmd: 0x");

Serial.println(cmdCompleteHeader->ncmd,HEX);

Serial.print("E opcode: 0x");

Serial.println(cmdCompleteHeader->opcode, HEX);

Serial.print("E status: 0x");

Serial.println(cmdCompleteHeader->status, HEX);

#endif

_cmdCompleteOpcode = cmdCompleteHeader->opcode;

_cmdCompleteStatus = cmdCompleteHeader->status;

_cmdResponseLen = pdata[1] - sizeof(CmdComplete);

_cmdResponse = &pdata[sizeof(HCIEventHdr) + sizeof(CmdComplete)];