blob: 8158a2f62673348329ead8a62073ce03365c4939 [file] [log] [blame]
/*
*
* Copyright (c) 2020 Project CHIP Authors
* Copyright (c) 2014-2017 Nest Labs, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file
* This file defines types and an object for the chip over
* Bluetooth Low Energy (CHIPoBLE) byte-stream, connection-oriented
* adaptation of chip for point-to-point Bluetooth Low Energy
* (BLE) links.
*
*/
#ifndef CHIPOBLE_H_
#define CHIPOBLE_H_
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#endif
#include <stdint.h>
#include <string.h>
#include <ble/BleConfig.h>
#include <ble/BleError.h>
#include <system/SystemPacketBuffer.h>
#include <support/FlagUtils.hpp>
namespace chip {
namespace Ble {
using ::chip::System::PacketBuffer;
typedef uint8_t SequenceNumber_t; // If type changed from uint8_t, adjust assumptions in CHIPoBle::IsValidAck and
// BLEEndPoint::AdjustReceiveWindow.
#if CHIP_ENABLE_CHIPOBLE_TEST
class BLEEndPoint;
#endif
// Public data members:
typedef enum
{
kType_Data = 0, // Default 0 for data
kType_Control = 1,
} PacketType_t; // CHIPoBle packet types
class CHIPoBle
{
#if CHIP_ENABLE_CHIPOBLE_TEST
friend class BLEEndPoint;
#endif
public:
// Public data members:
typedef enum
{
kState_Idle = 0,
kState_InProgress = 1,
kState_Complete = 2,
kState_Error = 3
} State_t; // [READ-ONLY] Current state
enum
{
kHeaderFlag_StartMessage = 0x01,
kHeaderFlag_ContinueMessage = 0x02,
kHeaderFlag_EndMessage = 0x04,
kHeaderFlag_FragmentAck = 0x08,
#if CHIP_ENABLE_CHIPOBLE_TEST
kHeaderFlag_CommandMessage = 0x10,
#endif
}; // Masks for BTP fragment header flag bits.
static const uint16_t sDefaultFragmentSize;
static const uint16_t sMaxFragmentSize;
public:
// Public functions:
CHIPoBle(void){};
~CHIPoBle(void){};
BLE_ERROR Init(void * an_app_state, bool expect_first_ack);
inline void SetTxFragmentSize(uint8_t size) { mTxFragmentSize = size; };
inline void SetRxFragmentSize(uint8_t size) { mRxFragmentSize = size; };
uint16_t GetRxFragmentSize(void) { return mRxFragmentSize; };
uint16_t GetTxFragmentSize(void) { return mTxFragmentSize; };
SequenceNumber_t GetAndIncrementNextTxSeqNum(void);
SequenceNumber_t GetAndRecordRxAckSeqNum(void);
inline SequenceNumber_t GetLastReceivedSequenceNumber(void) { return mRxNewestUnackedSeqNum; };
inline SequenceNumber_t GetNewestUnackedSentSequenceNumber(void) { return mTxNewestUnackedSeqNum; };
inline bool ExpectingAck(void) const { return mExpectingAck; };
inline State_t RxState(void) { return mRxState; }
inline State_t TxState(void) { return mTxState; }
#if CHIP_ENABLE_CHIPOBLE_TEST
inline PacketType_t SetTxPacketType(PacketType_t type) { return (mTxPacketType = type); };
inline PacketType_t SetRxPacketType(PacketType_t type) { return (mRxPacketType = type); };
inline PacketType_t TxPacketType() { return mTxPacketType; };
inline PacketType_t RxPacketType() { return mRxPacketType; };
inline SequenceNumber_t SetTxPacketSeq(SequenceNumber_t seq) { return (mTxPacketSeq = seq); };
inline SequenceNumber_t SetRxPacketSeq(SequenceNumber_t seq) { return (mRxPacketSeq = seq); };
inline SequenceNumber_t TxPacketSeq() { return mTxPacketSeq; };
inline SequenceNumber_t RxPacketSeq() { return mRxPacketSeq; };
inline bool IsCommandPacket(PacketBuffer * p) { return GetFlag(*(p->Start()), kHeaderFlag_CommandMessage); }
inline void PushPacketTag(PacketBuffer * p, PacketType_t type)
{
p->SetStart(p->Start() - sizeof(type));
memcpy(p->Start(), &type, sizeof(type));
};
inline PacketType_t PopPacketTag(PacketBuffer * p)
{
PacketType_t type;
memcpy(&type, p->Start(), sizeof(type));
p->SetStart(p->Start() + sizeof(type));
return type;
};
#endif // CHIP_ENABLE_CHIPOBLE_TEST
bool HasUnackedData(void) const;
BLE_ERROR HandleCharacteristicReceived(PacketBuffer * data, SequenceNumber_t & receivedAck, bool & didReceiveAck);
bool HandleCharacteristicSend(PacketBuffer * data, bool send_ack);
BLE_ERROR EncodeStandAloneAck(PacketBuffer * data);
PacketBuffer * RxPacket(void);
PacketBuffer * TxPacket(void);
bool ClearRxPacket(void);
bool ClearTxPacket(void);
void LogState(void) const;
void LogStateDebug(void) const;
private:
// Private data members:
#if CHIP_ENABLE_CHIPOBLE_TEST
PacketType_t mTxPacketType;
PacketType_t mRxPacketType;
SequenceNumber_t mTxPacketSeq;
SequenceNumber_t mRxPacketSeq;
#endif
State_t mRxState;
uint16_t mRxLength;
void * mAppState;
PacketBuffer * mRxBuf;
SequenceNumber_t mRxNextSeqNum;
SequenceNumber_t mRxNewestUnackedSeqNum;
SequenceNumber_t mRxOldestUnackedSeqNum;
uint16_t mRxFragmentSize;
State_t mTxState;
uint16_t mTxLength;
PacketBuffer * mTxBuf;
SequenceNumber_t mTxNextSeqNum;
SequenceNumber_t mTxNewestUnackedSeqNum;
SequenceNumber_t mTxOldestUnackedSeqNum;
bool mExpectingAck;
uint16_t mTxFragmentSize;
uint16_t mRxCharCount;
uint16_t mRxPacketCount;
uint16_t mTxCharCount;
uint16_t mTxPacketCount;
private:
// Private functions:
bool IsValidAck(SequenceNumber_t ack_num) const;
BLE_ERROR HandleAckReceived(SequenceNumber_t ack_num);
};
} /* namespace Ble */
} /* namespace chip */
#endif /* CHIPOBLE_H_ */