statistics

Get statistics of Bluetooth LE node

Since R2022a

collapse all in page

    Syntax

    nodeStatistics = statistics(bluetoothLENodeObj)

    Description

    This feature also requires the Wireless Network Toolbox™ product.

    nodeStatistics = statistics(bluetoothLENodeObj) returns the statistics of the Bluetooth® low energy (LE) node object, bluetoothLENodeObj.

    example

    Examples

    collapse all

    This example uses:

    Open Live Script

    This example enables you to:

    1. Create and configure a Bluetooth LE piconet with Central and Peripheral nodes.

    2. Create and configure a link layer (LL) connection between Central and Peripheral nodes.

    3. Add application traffic from the Central to Peripheral nodes.

    4. Create a custom channel, and plug it into the wireless network simulator.

    5. Simulate Bluetooth LE network and retrieve the statistics of the Central and Peripheral nodes.

    Create a wireless network simulator.

    networkSimulator = wirelessNetworkSimulator.init;

    Create a Bluetooth LE node, specifying the role as "central". Specify the name and position of the node.

    centralNode = bluetoothLENode("central",Name="CentralNode");
centralNode.Position = [0 0 0];                 % In x-, y-, and z-coordinates in meters

    Create a Bluetooth LE node, specifying the role as "peripheral". Specify the name and position of the node.

    peripheralNode = bluetoothLENode("peripheral",Name="PeripheralNode");
peripheralNode.Position = [10 0 10]              % In x-, y-, and z-coordinates in meters
    peripheralNode = 
  bluetoothLENode with properties:

        TransmitterPower: 20
         TransmitterGain: 0
            ReceiverGain: 0
     ReceiverSensitivity: -100
             NoiseFigure: 0
    InterferenceModeling: "overlapping-adjacent-channel"
                    Role: "peripheral"
        ConnectionConfig: [0×0 bluetoothLEConnectionConfig]
               CISConfig: [0×0 bluetoothLECISConfig]
                Position: [10 0 10]
                    Name: "PeripheralNode"
                Mobility: []

   Read-only properties:
                      ID: 2
                Velocity: [0 0 0]

    Add a random waypoint mobility model to the Bluetooth peripheral node. Set the shape of the node's mobility area to "circle".

    addMobility(peripheralNode,BoundaryShape="circle",RefreshInterval=0.1)

    Create a default Bluetooth LE configuration object to share the LL connection between the Central and Peripheral nodes.

    cfgConnection = bluetoothLEConnectionConfig;

    Specify the connection interval and connection offset. Throughout the simulation, the object establishes LL connection events for the duration of each connection interval. The connection offset is from the beginning of the connection interval. 

    cfgConnection.ConnectionInterval = 0.01; % In seconds
cfgConnection.ConnectionOffset = 0;      % In seconds

    Specify the active communication period after the connection event is established between the Central and Peripheral nodes.

    cfgConnection.ActivePeriod = 0.01 % In seconds
    cfgConnection = 
  bluetoothLEConnectionConfig with properties:

    ConnectionInterval: 0.0100
         AccessAddress: "5DA44270"
          UsedChannels: [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36]
             Algorithm: 1
          HopIncrement: 5
     CRCInitialization: "012345"
    SupervisionTimeout: 1
               PHYMode: "LE1M"
         InstantOffset: 6
      ConnectionOffset: 0
          ActivePeriod: 0.0100
                MaxPDU: 251
                  TIFS: 1.5000e-04
                 TMCES: 1.5000e-04

    Configure the connection between Central and Peripheral nodes by using the configureConnection object function of the bluetoothLEConnectionConfig object.

    configureConnection(cfgConnection,centralNode,peripheralNode);

    Create a networkTrafficOnOff (Wireless Network Toolbox) object to generate an On-Off application traffic pattern. Specify the data rate in kb/s and the packet size in bytes. Enable packet generation to generate an application packet with a payload.

    traffic = networkTrafficOnOff(DataRate=100,PacketSize=10);

    Add application traffic from the Central to the Peripheral node by using the addTrafficSource object function.

    addTrafficSource(centralNode,traffic,DestinationNode=peripheralNode);

    Create a Bluetooth LE network consisting of a Central and a Peripheral node.

    nodes = {centralNode peripheralNode};

    Add the Central and Peripheral nodes to the wireless network simulator.

    addNodes(networkSimulator,nodes)

    Add the custom channel to the wireless network simulator.

    addChannelModel(networkSimulator,@addImpairment);

    Set the simulation time in seconds and run the simulation.

    simulationTime = 0.5;
run(networkSimulator,simulationTime)

    Retrieve application, link layer (LL), and physical layer (PHY) statistics corresponding to the Central and Peripheral nodes. For more information about the statistics, see Bluetooth LE Node Statistics.

    centralStats = statistics(centralNode)
    centralStats = struct with fields:
    Name: "CentralNode"
      ID: 1
     App: [1×1 struct]
      LL: [1×1 struct]
     PHY: [1×1 struct]


    peripheralStats = statistics(peripheralNode)
    peripheralStats = struct with fields:
    Name: "PeripheralNode"
      ID: 2
     App: [1×1 struct]
      LL: [1×1 struct]
     PHY: [1×1 struct]

    Follow these steps to create a custom channel that models Bluetooth path loss for an industrial scenario.

    • Create a custom function with this syntax: rxData = customFcnName(rxInfo,txData). The rxInfo input specifies the receiver node information as a structure, and the txData input specifies the transmitted packets as a structure. The simulator automatically passes information about the receiver node and the packets transmitted by a transmitter node as inputs to the custom function. For more information about creating custom channel, see the addChannelModel (Wireless Network Toolbox) object function.

    • Use the bluetoothPathLossConfig object to set path loss configuration parameters for an industrial scenario.

    • Calculate path loss between the Central and Peripheral nodes using the bluetoothPathLoss function. Specify the transmitter and receiver positions.

    • Apply path loss to the transmitted packets.

    function rxData = addImpairment(rxInfo,txData)

    pathlossCfg = bluetoothPathLossConfig(Environment="Industrial");

    % Apply path loss and update output signal
    rxData = txData;

    % Calculate the distance between transmitter and receiver in meters
    distance = norm(rxData.TransmitterPosition - rxInfo.Position);
    pathloss = bluetoothPathLoss(distance,pathlossCfg);
    rxData.Power = rxData.Power-pathloss;                           % In dBm
    scale = 10.^(-pathloss/20);
    [numSamples,~] = size(rxData.Data);
    rxData.Data(1:numSamples,:) = rxData.Data(1:numSamples,:)*scale;
end

    Input Arguments

    collapse all

    Bluetooth LE node object, specified as a bluetoothLENode object or a vector of bluetoothLENode objects. If you specify this input as a bluetoothLENode object, this object function returns the nodeStatistics output as a structure. If you specify this input as a vector of bluetoothLENode objects, this object function returns the nodeStatistics output as a vector of structures.

    Output Arguments

    collapse all

    Statistics of the Bluetooth LE node, returned as a structure or a vector of structures. For more information about this output, see Bluetooth LE Node Statistics.

    Data Types: struct

    References

    [1] Bluetooth Technology Website. “Bluetooth Technology Website | The Official Website of Bluetooth Technology.” Accessed January 10, 2026. https://www.bluetooth.com/.

    [2] Bluetooth Special Interest Group (SIG). "Bluetooth Core Specification". v6.1. https://www.bluetooth.com/.

    Version History

    Introduced in R2022a

    expand all

    See Also

    Objects

    Functions

    Topics