Main Content

Evaluate the Performance of Bluetooth QoS Traffic Scheduling with WLAN Signal Interference

This example shows you how to evaluate the performance of the Bluetooth® scheduler by implementing multiple applications with different quality-of-service (QoS) requirements (throughput and latency) in a use-case scenario. Using this example, you can:

  • Create and configure a use-case scenario of a home environment showing multiple Bluetooth applications in a piconet with WLAN interference.

  • Emulate and configure the application traffic pattern by using the generic On-Off traffic model.

  • Implement round-robin (RR) and QoS-based priority schedulers to schedule application traffic.

  • Add your own custom scheduler.

  • Specify the source of WLAN interference by adding the WLAN signal using the features of WLAN Toolbox™ or from a baseband file.

  • Evaluate the performance of each Peripheral in the presence of a synchronous connection-oriented (SCO) link and by varying the scheduler.

The example supports adaptive frequency hopping (AFH) by classifying channels as good or bad based on the packet error rate (PER) of each channel. Visualize the power spectral density of Bluetooth waveforms with a WLAN signal interference using the Spectrum Analyzer.

Bluetooth Logical Transports and Application Profiles

Bluetooth Technology Overview supports communication over multiple logical transports with different applications running on it. These applications include audio streaming, gaming controls, wireless peripherals, and file transfer applications. Because multiple applications can exist in a Bluetooth piconet, different types of application traffic flow from the higher layers to the baseband.

Logical Transports

In a Bluetooth piconet, the Central and Peripheral exchange data over multiple logical transports. These logical transports are:

  • Asynchronous connection-oriented (ACL)

  • SCO

  • Extended synchronous connection-oriented (eSCO)

  • Active peripheral broadcast (APB)

  • Connectionless peripheral broadcast (CPB)

This figure shows the communication between a Central and three Peripherals in a piconet over ACL and SCO logical transports. Because Bluetooth is a Central-driven time division duplex (TDD) system, the channel access in the piconet is controlled by the Central. The Peripheral can respond to only a transmission from the Central in the previous Tx slot. This process is called polling.

BluetoothSchedulingExample_01.png

The Central polls a Peripheral with a poll packet (if no data exists) or a data packet in a Tx slot, and the Peripheral responds to the polling. The Central can poll any Peripheral of the SCO or ACL logical transport. For SCO links, the Central reserves the slots for the dedicated SCO Peripheral. The Central polls the ACL Peripherals in the remaining slots. The Peripheral responds to the Central with a data packet or a null packet.

Application Profiles

Bluetooth profiles (often called application profiles) are definitions of possible applications and specify general behaviors that Bluetooth-enabled devices use to communicate with other Bluetooth devices. The Bluetooth Special Interest Group (SIG) [ 2 ] defines these profiles and the possible applications of each profile.

In general, Bluetooth application traffic can be categorized into these three classes.

  • Streaming - These applications have latency and bandwidth requirements. For example, a headphone or a laptop.

  • Human interface devices (HID) - These applications have low latency requirements. For example, a keyboard or a joystick.

  • Best-effort traffic - These applications have no latency requirements. For example, file transfer using Bluetooth.

Each Peripheral corresponds to a specific application profile. Typically, the amount of traffic flow in each application profile varies. Also, the throughput and latency performance requirements of each application profile are different. In such scenarios, if the implementation uses an RR scheduler for polling the ACL Peripherals, and if the polled Peripherals do not have data to transmit, this results in low bandwidth utilization by Peripherals. To help improve performance, prioritize the ACL Peripherals for polling based on the QoS requirements.

In this example, the Bluetooth nodes operate with the basic rate (BR) physical layer (PHY) and communicate with each other simultaneously by transmitting the application data packets (on the ACL link). This example simulates a use-case scenario consisting of multiple Bluetooth devices that communicate by emulating the traffic pattern of FTP and A2DP application profiles. For more details, see Use-Case Scenario.

Use-Case Scenario

This example shows a use-case scenario of a home environment, where a smartphone (Central) connects to a laptop (Peripheral 1), wireless speaker (Peripheral 2), and smartphone (Peripheral 3). All of the devices are Bluetooth-BR-enabled. You can enable or disable presence of static WLAN signal interference in the vicinity of the Bluetooth piconet.

BluetoothSchedulingExample_02.png

In the preceding figure:

  • The Central transfers a file to the laptop (Peripheral 1) on the ACL link by emulating the FTP traffic pattern.

  • The Central streams music in the wireless speaker (Peripheral 2) on the ACL link by emulating the A2DP traffic pattern.

  • The Central transfers another file smartphone (Peripheral 3) on the ACL link by emulating the FTP traffic pattern.

In the preceding scenario, the performance of each Peripheral degrades due to these reasons.

  • Concurrent communication by various Bluetooth applications

  • Presence of WLAN signal interference in the wireless medium (if enabled)

This example shows how to simulate this use-case scenario and how to measure the communication performance. To communicate with the laptop (Peripheral 1), wireless speaker (Peripheral 2), and smartphone (Peripheral 3) on the ACL links, the Central uses the RR scheduling mechanism. The RR scheduling mechanism provides equal transmission and reception opportunities for Peripheral 1, Peripheral 2, and Peripheral 3. Because, Peripheral 2 has QoS requirements (related to throughput and latency), Peripheral 2 must be prioritized. The RR scheduling mechanism fails to prioritize the communication opportunities of Peripheral 2, resulting in the degradation of communication performance. To mitigate the performance degradation at Peripheral 2 and help improve performance the example uses the QoS-based priority scheduling mechanism at the Central. The example also shows how to add a custom scheduling algorithm, enabling you to schedule application traffic with specific performance requirements.

Configure Simulation Parameters

Configure the simulation parameters for the Bluetooth piconet, the application traffic, the wireless channel, and the WLAN signal interference.

Configure Bluetooth Piconet

The NumPeripherals parameter specifies the number of Peripherals in the Bluetooth piconet. The LinkTraffic parameter specifies the type of traffic over Bluetooth logical transports between a Central and the respective Peripheral. This table maps LinkTraffic to different logical transports. If the Central communicates with multiple Peripherals, LinkTraffic must be a vector.

% Set the simulation time in microseconds
simulationTime = 2*1e6;

% Specify to enable (true) or disable (false) visualization
enableVisualization = true;

simulationParameters = struct;
% Configure the number of Peripherals in the piconet
simulationParameters.NumPeripherals = 3;

% Configure the logical links between the Central and Peripherals. Each element
% represents the logical link between the Central and the respective Peripheral.
% If the Central is connected to multiple Peripherals, this value must be a row
% vector.
simulationParameters.LinkTraffic = [1 1 1];

% Specify the positions of Bluetooth nodes in the form of an n-by-3 array,
% where n is the number of nodes in the piconet. Each row specifies the
% cartesian coordinates of a node starting from the Central and followed by
% the Peripherals.
simulationParameters.NodePositions = [10 0 0; 20 0 0; 30 0 0; 40 0 0];

% Configure the frequency hopping sequence as Connection adaptive (for
% enabling AFH) or Connection basic
simulationParameters.SequenceType = 'Connection adaptive';

Configure Application Traffic Pattern

This example shows how to use a generic On-Off model for emulating the application traffic pattern. To emulate the application traffic pattern of the ACL Peripherals (Peripheral 1, Peripheral 2, and Peripheral 3), use the helperBluetoothNetworkTraffic. To model the traffic pattern, specify the application token rate (bit rate), frame size, access latency, and the values for OnTime and OffTime properties of the object. If you specify SCO Peripherals, model the application traffic pattern based on the packet type. For each transmission, the data (random bits) is made available at the baseband layer. In the majority of the scenarios involving ACL links, the traffic flow is present at the source, and the sink sends only the acknowledgement. In this example, all of the sources are present at the Central.

% Load the Bluetooth application traffic pattern configuration
load('bluetoothTrafficConfig.mat');

% Specify the parameters for SCO application. To enable an SCO logical
% transport, set the linkTraffic value at the Peripheral index to 2 or 3.
% Specify the SCO packet type as 'HV1', 'HV2', or 'HV3' for the respective
% Peripheral that has SCO link traffic. Index 1 represents the Peripheral
% number, and index 2 represents the SCO packet type to be used by the
% Peripheral.
simulationParameters.SCOPacketType = {};

% Compute the number of ACL Peripherals
numACLPeripherals = nnz(simulationParameters.LinkTraffic ~= 2);
aclApplications = repmat({bluetoothTrafficConfig}, 1, numACLPeripherals);

% Update the configuration at the first ACL application (for example, a
% laptop). You can observe the variation in throughput based on the
% configured data rate and packet size.
aclApplications{1}.PeripheralNumber = 1;            % Peripheral LT address
aclApplications{1}.TrafficPattern = 'FTP';          % FTP traffic pattern
aclApplications{1}.PacketSize = 152;                % In bytes
aclApplications{1}.DataRateKbps = 224;              % In Kbps
aclApplications{1}.ApplicationOnTime = 2;           % In milliseconds
aclApplications{1}.ApplicationOffTime = 0;          % In milliseconds
aclApplications{1}.AccessLatency = 500;             % In milliseconds
aclApplications{1}.Role = 'Central';                % Install the application at 'Central', 'Peripheral', or 'Both'

% Update the configuration at the second ACL application (for example, a
% wireless speaker).
aclApplications{2}.PeripheralNumber = 2;            % Peripheral LT address
aclApplications{2}.TrafficPattern = 'A2DP';         % A2DP traffic pattern
aclApplications{2}.PacketSize = 328;                % In bytes
aclApplications{2}.DataRateKbps = 237;              % In Kbps
aclApplications{2}.ApplicationOnTime = 2;           % In milliseconds
aclApplications{2}.ApplicationOffTime = 0;          % In milliseconds
aclApplications{2}.AccessLatency = 60;              % In milliseconds
aclApplications{2}.Role = 'Central';                % Install the application at 'Central', 'Peripheral', or 'Both'

% Update the configuration at the third ACL application (for example, a
% smartphone).
aclApplications{3}.PeripheralNumber = 3;            % Peripheral LT address
aclApplications{3}.TrafficPattern = 'FTP';          % FTP traffic pattern
aclApplications{3}.PacketSize = 164;                % In bytes
aclApplications{3}.DataRateKbps = 172;              % In Kbps
aclApplications{3}.ApplicationOnTime = 2;           % In milliseconds
aclApplications{3}.ApplicationOffTime = 0;          % In milliseconds
aclApplications{3}.AccessLatency = 500;             % In milliseconds
aclApplications{3}.Role = 'Central';                % Install the application at 'Central', 'Peripheral', or 'Both'

% Configure the application traffic objects
for appIdx = 1:numACLPeripherals
    appCfg = aclApplications{appIdx};
    app = helperBluetoothNetworkTraffic( ...
        'PacketSize',appCfg.PacketSize, ...     % In bytes
        'DataRate',appCfg.DataRateKbps, ...     % In Kbps
        'OnTime',appCfg.ApplicationOnTime, ...  % In milliseconds
        'OffTime',appCfg.ApplicationOffTime);   % In milliseconds
    aclApplications{appIdx}.AppTrafficPattern = app;
end
simulationParameters.ACLApplications = aclApplications;

Configure Scheduler

Configure the scheduler to be used at the baseband layer. To configure the RR and priority scheduler, use the helperBluetoothRRScheduler and helperBluetoothPriorityScheduler helper objects, respectively. You can also add a custom scheduler at the baseband layer. For information about how to implement and integrate a custom scheduler, see Compare Performance of Peripherals by varying Scheduling Algorithm.

% Specify the scheduling scheme as 'RR' or 'Priority'
simulationParameters.Scheduler = "Priority";

Configure Wireless Channel and WLAN Signal Interference

Configure the wireless channel by using the helperBluetoothChannel helper object and set the SIR value at each node. You can set the EbNo value for the AWGN channel. The AWGN is present throughout the simulation.

To generate the WLAN signal interference, use the helperBluetoothGenerateWLANWaveform helper function. Specify the sources of WLAN interference by using the WLANInterference parameter. Use one of these options to specify the source of the WLAN interference.

  • 'Generated' - To add a WLAN toolbox™ signal to interfere the communication between Bluetooth nodes, select this option. For details on how to add this signal, follow the steps shown in Add WLAN Signal Using WLAN Toolbox™ Features.

  • 'BasebandFile' - To add a WLAN signal from a baseband file (.bb) to interfere the communication between Bluetooth nodes, select this option. You can specify the file name using the WLANBBFilename input argument. If you do not specify the .bb file, the example uses the default .bb file, 'WLANNonHTDSSS.bb', to add the WLAN signal.

The 'None' option specifies that no WLAN signal is added to the Bluetooth signals, and the example uses this option by default.

% Configure wireless channel parameters
simulationParameters.EbNo = 22; % Ratio of energy per bit (Eb) to spectral noise density (No) in dB

% Configure the WLAN interference. Specify the WLAN interference as
% Generated, BasebandFile, or None. To use the wlanBBFilename property, set
% wlanInterference to BasebandFile.
simulationParameters.WLANInterference = 'None';
simulationParameters.WLANBBFilename =  'WLANNonHTDSSS.bb';

% Specify the signal to interference ratio, in dB, at each node. Specify
% this value as an n-element vector, where n is the number of nodes in the
% piconet, starting from the Central and followed by the Peripherals. 
% Each value indicates the SIR at a node.
simulationParameters.SIR = [-12 -6 -10 -8];

Create Bluetooth Piconet

Create a Bluetooth piconet of nodes with an L2CAP layer, baseband layer, PHY, and channel. To configure the Bluetooth piconet from the configured parameters, use the helperBluetoothCreatePiconet helper function.

% Set the default random number generator ('twister' type with seed value 0).
% The seed value controls the pattern of random number generation. For high
% fidelity simulation results, change the seed value and average the
% results over multiple simulations.
rng('default');

% Specify the Tx power in dBm
simulationParameters.TxPower = 20;

% Specify the Bluetooth node receiver range (in meters).
simulationParameters.ReceiverRange = 40;

% Configure the channel classification parameters
simulationParameters.PERThreshold = 40;
simulationParameters.ClassificationInterval = 3000;
simulationParameters.RxStatusCount = 10;
simulationParameters.MinRxCountToClassify = 4;
simulationParameters.PreferredMinimumGoodChannels = 20;

% Set the total number of nodes in the piconet (one Central and multiple
% Peripherals)
numNodes = simulationParameters.NumPeripherals + 1;

% Configure the Bluetooth piconet
bluetoothNodes = helperBluetoothCreatePiconet(simulationParameters);

Visualize the Bluetooth waveforms by using the spectrumAnalyzer (DSP System Toolbox) object.

if enableVisualization
    spectrumAnalyzer = spectrumAnalyzer( ...
        'ViewType','Spectrum and spectrogram', ...
        'TimeResolutionSource','Property', ...
        'TimeResolution',0.0005, ...                                 % In seconds
        'TimeSpanSource','Property', ...
        'TimeSpan',0.05, ...                                         % In seconds
        'RBWSource', 'property', ...
        'RBW', 257.812e3, ...
        'AxesLayout','Horizontal', ...
        'FrequencyOffset',2441*1e6, ...                              % In Hz
        'SampleRate',bluetoothNodes{1}.PHY.SamplesPerSymbol*1e6, ... % In Hz
        'ColorLimits',[-20 15]);
end

Simulation

Run the Bluetooth piconet simulation by calling each node instance. Distribute the Tx packets from each node to the Rx buffer of the other nodes, and then advance the simulation time to the next event of a node. Update the spectrum analyzer visualization.

% Specify the current simulation time, elapsed time, and next invoke times
% for all of the nodes in microseconds
curTime = 0;
elapsedTime = 0;
nextInvokeTimes = zeros(1, numel(bluetoothNodes));
slotPerSec = 1600;

% View buffer size at each ACL Peripheral
if enableVisualization
    channelNames = cell(1, numACLPeripherals);
    for idx=1:numACLPeripherals
        channelNames{idx} = bluetoothNodes{idx+1}.NodeName;
    end
    bufferSizeVisualization = timescope( ...
        'Name','Buffer Size of each ACL Peripheral at Central', ...
        'SampleRate',slotPerSec*1.25*simulationTime/1e6, ... % In Hz
        'AxesScaling','auto', ...
        'ShowLegend',true, ...
        'TimeSpanSource','property', ...
        'TimeSpan',simulationTime/1e6, ...                   % In seconds
        'YLabel','Buffer Size', ...
        'YLimits',[0 5], ...
        'ChannelNames',channelNames);
    bufferSizeVisualization(zeros(1, numACLPeripherals));
    if ~strcmpi(simulationParameters.WLANInterference, 'None')
        % Generate the WLAN waveform for visualization
        wlanWaveform = helperBluetoothGenerateWLANWaveform(...
            simulationParameters.WLANInterference, simulationParameters.WLANBBFilename);
    end
end

% Run the simulation
while(curTime < simulationTime)
    % Simulate the Bluetooth nodes
    for nodeIdx = 1:numel(bluetoothNodes)
        % Run the Bluetooth node instance
        nextInvokeTimes(nodeIdx) = runNode(bluetoothNodes{nodeIdx}, elapsedTime);

        % Update the visualization
        if enableVisualization
            % Update and plot the buffer status at the Central
            if nodeIdx == 1
                [~, emptySlots] = bluetoothNodes{1}.Baseband.aclLinkAddress;
                bufferSize = helperBluetoothLogicalTransports.MaxQueueSize - emptySlots;
                bufferSizeVisualization(bufferSize);
            end
        end
    end

    % Advance the current time by the elapsed time
    curTime = curTime + elapsedTime;

    % Distribute any transmitted packets from each node into the receiving
    % buffers of the other nodes
    [isPacketDistributed, txBuffer] = helperBluetoothDistributePackets(bluetoothNodes);
    
    % Update visualization
    if enableVisualization
        for txIdx = 1:numel(txBuffer)
            channelWaveform = txBuffer{txIdx}.Waveform(1:txBuffer{txIdx}.NumSamples);
            if ~strcmpi(simulationParameters.WLANInterference, 'None')
                % Add WLAN interference to the channel waveform.
                channelWaveform = channelWaveform + wlanWaveform(1:txBuffer{txIdx}.NumSamples);
            end

            % Plot the Bluetooth waveform.
            spectrumAnalyzer(channelWaveform);
        end
    end

    % If packets are distributed to the receiver nodes, run the nodes to
    % check the packet reception buffer
    if isPacketDistributed
        elapsedTime = 0;
        % Advance the simulation time to the next event at a node
    else
        elapsedTime = min(nextInvokeTimes(nextInvokeTimes ~= -1));
    end
end
ans = 1x79 logical array

   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1

ans = 1x79 logical array

   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1

ans = 1x79 logical array

   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1

% Release the System objects
if enableVisualization
    release(bufferSizeVisualization);
    release(spectrumAnalyzer);
end

The preceding Spectrum Analyzer plot shows the spectrum of the Bluetooth waveform distorted with WLAN signal interference (in the frequency domain) and passed through the AWGN channel. The right-side plot shows the overlapping of Bluetooth packets with the interfering WLAN signal. The WLAN waveform in the plot is present throughout the simulation.

Simulation Results

At each node, the simulation measures these metrics.

  • Throughput at application (L2CAP)

  • PER

  • Bit error rate (BER)

  • Packet statistics at the PHY, baseband layer, and L2CAP layer

In addition to those metrics, at each Peripheral, the simulation measures these metrics.

  • Latency (only for ACL Peripherals)

  • Fairness of scheduler

These metrics are generated during the simulation and stored in the centralStats and peripheralsStats table. For more information on these statistics, refer helperBluetoothSchedulingStatistics helper function. Get the metrics of each Bluetooth Peripheral in the piconet.

[centralStats, peripheralsStats] = helperBluetoothSchedulingStatistics(bluetoothNodes, ...
    simulationParameters.LinkTraffic, simulationParameters.SCOPacketType, simulationTime)
centralStats=1×11 table
               Throughput (Kbps)    PER    BER    TotalTxPackets    TotalRxPackets    ValidRxPackets    DroppedRxPackets    TxACLPackets    RxACLPackets    TxSCOPackets    RxSCOPackets
               _________________    ___    ___    ______________    ______________    ______________    ________________    ____________    ____________    ____________    ____________

    Central         569.41           0      0          712               711               711                 0            {7x2 double}    {7x2 double}    {7x2 double}    {7x2 double}

peripheralsStats=3×17 table
                         Traffic Pattern    Application Data Rate (Kbps)    Throughput (Kbps)    Latency (ms)    Maximum Latency (ms)    Minimum Latency (ms)    PER    BER    Fairness    TotalTxPackets    TotalRxPackets    ValidRxPackets    DroppedRxPackets    TxACLPackets    RxACLPackets    TxSCOPackets    RxSCOPackets
                         _______________    ____________________________    _________________    ____________    ____________________    ____________________    ___    ___    ________    ______________    ______________    ______________    ________________    ____________    ____________    ____________    ____________

    Peripheral1 (ACL)        "FTP"                      224                      223.74              4.507               8.242                   2.008            0      0      51.966          369               711               369                342             {[369]}         {[369]}          {[0]}           {[0]}    
    Peripheral2 (ACL)        "A2DP"                     237                      237.47              4.481               5.743                   1.011            0      0      25.562          182               711               182                529             {[182]}         {[182]}          {[0]}           {[0]}    
    Peripheral3 (ACL)        "FTP"                      172                       104.3             61.871              70.751                  10.751            0      0      22.472          160               711               160                551             {[160]}         {[160]}          {[0]}           {[0]}    

Further Exploration

Because the presence of an SCO Peripheral in the piconet reserves the slots, the bandwidth for ACL Peripherals decreases. Consequently, the presence of an SCO Peripheral results in the suspension of most of the ongoing ACL transmissions. In the default configuration, as the simulation uses the priority scheduler, wireless speaker (Peripheral 2) is prioritized over laptop (Peripheral 1) and smartphone (Peripheral 2). In this case, audio streaming has a better throughput and lower latency than the file transfer.

You can further evaluate and compare the performance of Peripherals:

  • In the presence of an SCO link

  • By varying the scheduling algorithm

Compare Performance of Peripherals in Presence of SCO Link

Simulate the scenario for 3 seconds with a QoS-based scheduler and with WLAN signal interference enabled. Compare the throughput and latency by enabling and then disabling the SCO link at Peripheral 3.

BluetoothSchedulingExample_06.jpeg

The presence of the SCO link degrades the throughput and latency performance of ACL Peripherals. And also, the wireless speaker (Peripheral 2) cannot achieve the required throughput if an SCO Peripheral in the piconet exists, even if you use a QoS-based priority scheduler. Because acknowledgement for SCO packets is not required, the latency is calculated only for the ACL Peripherals.

Compare Performance of Peripherals by varying Scheduling Algorithm

Simulate the scenario for 3 seconds with the RR and QoS-based priority scheduler. Enable WLAN signal interference for both scenarios throughout the simulation.

BluetoothSchedulingExample_07.jpeg

For the RR scheduler, the throughput and latency values are approximately same for the laptop, wireless speaker, and smartphone. The QoS-based priority scheduler achieves the desired throughput and low latency of the wireless speaker (Peripheral 2).

You can use parameters such as PER, BER, level of WLAN interference, and channel map to create your own custom scheduler and evaluate its performance using this simulation. For more details on experimenting with channel classification, see Bluetooth BR Data and Voice Communication with WLAN Signal Interference. Follow these steps to implement and integrate a custom Bluetooth scheduler.

  1. Use the helperBluetoothScheduler helper object to create a new scheduler object.

  2. Implement the algorithm by defining the runScheduler function. Modify the helperBluetoothBaseband helper object to update and retrieve the newly added parameters required by the algorithm.

  3. Update the logic to attach the scheduler to the node in the helperBluetoothCreatePiconet helper function based on the algorithm.

Add WLAN Signal Using WLAN Toolbox™ Features

To add a WLAN signal using WLAN Toolbox™ features, set the value of wlanInterference to Generated. Use this code to add the generated WLAN signal as static signal interference to Bluetooth. Use this sample code snippet in WLAN signal generation using WLAN Toolbox™ features.

% % Create a WLAN waveform to interfere with Bluetooth waveforms,
% % which can be modified by using the features of the WLAN Toolbox.
% psduLength = 1000;
%
% % Create a configuration object for generating the WLAN waveform (802.11b)
% cfgNHT = wlanNonHTConfig('Modulation','DSSS', ...
%     'PSDULength', psduLength);
%
% % Create a random payload
% payload = randi([0 1], cfgNHT.PSDULength*8, 1);
%
% % Generate the WLAN waveform
% wlanWaveform = wlanWaveformGenerator(payload, cfgNHT);

You can add your custom signal generation code in the helperBluetoothGenerateWLANWaveform helper function. You can also write the respective signal WLAN spectrum masks and register to the WLANSpectrum property of the helperBluetoothChannel helper object as a function pointer.

This example simulates a home environment use-case scenario and demonstrates how to schedule Bluetooth FTP and A2DP application traffic on ACL link. The example uses the RR and QoS-based priority scheduling algorithms to schedule the application traffic. The results show that the QoS-based priority scheduling algorithm prioritizes A2DP traffic and gives a better throughput and latency performance of the wireless speaker (Peripheral 2). The results from further explorations indicate that the performance of ACL Peripherals decreases in the presence of SCO Peripherals.

Appendix

The example uses these helpers:

Selected Bibliography

  1. Bluetooth Technology Website. “Bluetooth Technology Website | The Official Website of Bluetooth Technology.” Accessed November 29, 2021. https://www.bluetooth.com/.

  2. Bluetooth Special Interest Group (SIG). "Bluetooth Core Specification." Version 5.3. https://www.bluetooth.com/.

  3. Bluetooth Special Interest Group (SIG). "Traditional Profile Specifications." . https://www.bluetooth.com/.

Related Topics