Audio Processing #1: Basic Terminologies

on
0

A Comprehensive Guide to Setting Up and Troubleshooting Bluetooth & BLE on Raspberry Pi

on

https://www.researchgate.net/profile/Claudio-Palazzi-2/publication/241628312/figure/fig1/AS:651189989437446@1532267200512/High-level-PulseAudio-architecture.png


Introduction:
Bluetooth and Bluetooth Low Energy (BLE) are key technologies in IoT projects, wireless audio applications, and sensor networks. The Raspberry Pi 3 Model B+ comes with built-in Bluetooth support, but setting it up and resolving issues can be tricky.

This blog provides a step-by-step guide to help you set up Bluetooth and BLE on your Raspberry Pi and troubleshoot common problems. The process and commands provided are based on real-world scenarios that occurred during the setup process.

1. Preparing the Raspberry Pi for Bluetooth Setup

Before configuring Bluetooth, ensure your Raspberry Pi 3 Model B+ is updated.

Step 1: Update and Upgrade the Raspberry Pi
To start, update your system by running:
sudo apt-get update and
sudo apt-get upgrade.
This ensures the latest software and drivers are installed.

Step 2: Verify Bluetooth Service
Check if the Bluetooth service is running with systemctl status bluetooth.
If it isn’t active, start it by executing sudo systemctl start bluetooth.

2. Configuring Bluetooth: Common Steps

Step 1: Check for Bluetooth Controller
Check if the Bluetooth controller is detected with hciconfig.
If no controller appears, move to the next steps for troubleshooting.

Step 2: Unblock Bluetooth
To check if Bluetooth is blocked by the system, run rfkill list.
If Bluetooth is soft-blocked, unblock it with sudo rfkill unblock bluetooth.

Step 3: Start the hciuart Service
If you encounter HCI controller errors, restart the hciuart service using:
sudo systemctl restart hciuart
You can check its status with sudo systemctl status hciuart.

3. Handling Common Bluetooth Issues

Issue 1: No Bluetooth Device Found
If hciconfig doesn’t display any controller, load the HCI UART module:
sudo modprobe hci_uart
Then check again with hciconfig.

You should see output similar to:

hci0:   Type: Primary  Bus: UART
        BD Address: B8:27:EB:XX:XX:XX  ACL MTU: 1021:8  SCO MTU: 64:1
        UP RUNNING
        RX bytes:718 acl:0 sco:0 events:39 errors:0
        TX bytes:446 acl:0 sco:0 commands:39 errors:0
Ensure that it is UP and RUNNING. If not, bring it up:

sudo hciconfig hci0 up

If you see a response like hci0: Type: Primary Bus: UART, your controller is active.

Issue 2: Editing /boot/config.txt for UART Settings
If Bluetooth still isn’t working, you might need to add the Bluetooth UART overlay.

  1. Open the config.txt file with sudo nano /boot/config.txt.
  2. Add the following line to enable proper UART configuration:
    dtoverlay=pi3-miniuart-bt.
  3. Save the file and reboot the Raspberry Pi by running sudo reboot.

4. Using Bluetoothctl to Pair Devices

bluetoothctl is a versatile tool for managing Bluetooth devices.

Step 1: Launch Bluetoothctl
Open Bluetooth control by typing bluetoothctl.

Step 2: Power On the Controller
Ensure the Bluetooth adapter is powered on with power on.

Step 3: Enable Scanning
Enable scanning to detect nearby devices by typing scan on.
Once you see your device in the list, note down its MAC address.

Step 4: Pair and Connect to the Device
To pair with a device, type pair <MAC address> and
to connect, use connect <MAC address>.
If the connection fails, trust the device first by running trust <MAC address>.

5. Setting Up BLE on Raspberry Pi

For working with BLE devices, you’ll use tools from the BlueZ package.

Step 1: Install BlueZ Utilities
Make sure you have BlueZ installed by running:
sudo apt-get install bluez.

Step 2: Use gatttool to Connect to BLE Devices
To interact with BLE devices, run sudo gatttool -b <MAC address> -I to enter interactive mode.
Then, connect to the device by typing connect.

6. Additional Troubleshooting

Failed to Start HCIUART Service
If the command sudo systemctl start hciuart fails, check the logs for more details with:
sudo journalctl -u hciuart.

Check dmesg for Bluetooth Errors
You can also check kernel messages related to Bluetooth by running:
dmesg | grep -i bluetooth, or for HCI issues, use dmesg | grep -i hci.

7. Managing Bluetooth Power Consumption and Disabling Bluetooth

If you no longer need Bluetooth, you can disable it to conserve system resources.

  1. Add this line to the /boot/config.txt file:
    dtoverlay=pi3-disable-bt.
  2. Disable the hciuart service with:
    sudo systemctl disable hciuart.
 

8. Troubleshooting the intermittent bluetooth sound playback latency issue

pactl list | grep -Pzo '.*bluez_card(.*\n)*'
        Name: bluez_card.30_C0_1B_96_F4_27
        Driver: module-bluez5-device.c
        Owner Module: 22
        Properties:
                device.description = "JBL GO"
                device.string = "30:C0:1B:96:F4:27"
                device.api = "bluez"
                device.class = "sound"
                device.bus = "bluetooth"
                device.form_factor = "headset"
                bluez.path = "/org/bluez/hci0/dev_30_C0_1B_96_F4_27"
                bluez.class = "0x240404"
                bluez.alias = "JBL GO"
                device.icon_name = "audio-headset-bluetooth"
                device.intended_roles = "phone"
        Profiles:
                headset_head_unit: Headset Head Unit (HSP/HFP) (sinks: 1, sources: 1, priority: 30, available: yes)
                a2dp_sink: High Fidelity Playback (A2DP Sink) (sinks: 1, sources: 0, priority: 40, available: yes)
                off: Off (sinks: 0, sources: 0, priority: 0, available: yes)
        Active Profile: a2dp_sink
        Ports:
                headset-output: Headset (type: Headset, priority: 0, latency offset: 0 usec, availability unknown)
                        Part of profile(s): headset_head_unit, a2dp_sink
                headset-input: Headset (type: Headset, priority: 0, latency offset: 0 usec, availability unknown)
                        Part of profile(s): headset_head_unit 


Changing the latency offset
pactl set-port-latency-offset bluez_card.30_C0_1B_96_F4_27 headset-output 50000 
Restarting the bluetooth service
sudo service bluetooth restart
Now checking if the latency offset updated
pactl list | grep -Pzo '.*bluez_card(.*\n)*'
        Name: bluez_card.30_C0_1B_96_F4_27
        Driver: module-bluez5-device.c
        Owner Module: 23
        Properties:
                device.description = "JBL GO"
                device.string = "30:C0:1B:96:F4:27"
                device.api = "bluez"
                device.class = "sound"
                device.bus = "bluetooth"
                device.form_factor = "headset"
                bluez.path = "/org/bluez/hci0/dev_30_C0_1B_96_F4_27"
                bluez.class = "0x240404"
                bluez.alias = "JBL GO"
                device.icon_name = "audio-headset-bluetooth"
                device.intended_roles = "phone"
        Profiles:
                headset_head_unit: Headset Head Unit (HSP/HFP) (sinks: 1, sources: 1, priority: 30, available: yes)
                a2dp_sink: High Fidelity Playback (A2DP Sink) (sinks: 1, sources: 0, priority: 40, available: yes)
                off: Off (sinks: 0, sources: 0, priority: 0, available: yes)
        Active Profile: a2dp_sink
        Ports:
                headset-output: Headset (type: Headset, priority: 0, latency offset: 50000 usec, available)
                        Part of profile(s): headset_head_unit, a2dp_sink
                headset-input: Headset (type: Headset, priority: 0, latency offset: 0 usec, availability unknown)
                        Part of profile(s): headset_head_unit

Now play the sound it should work properly

9. Optimizing Linux Performance and Audio: A Deep Dive into nice and pactl

Linux power users know that the terminal is where true control lies. Two commands that might not get the spotlight they deserve are nice and pactl. While nice allows users to adjust the priority of system processes, pactl provides real-time control over audio devices via PulseAudio.

The nice Command: Prioritizing System Processes for Optimal Performance

The nice command is a powerful tool in Linux for setting the priority of a process. When we launch a process with nice, we assign it a “niceness” value that influences how the system scheduler allocates CPU time to it. A process with a high niceness value runs with lower priority, consuming less CPU, while a lower niceness value will allow it to take precedence over other processes.
How nice Works

The range of nice values in Linux is from -20 to 19, where:

    -20 is the highest priority, meaning it demands more CPU resources.
    19 is the lowest priority, meaning the process is “nicer” to others, taking up fewer resources.

    Using nice for Process Management

To start a command with a specific nice value, you simply prefix it with nice -n <value>. For example, nice -n 10 <command> launches <command> with a niceness of 10, signaling the system to give it a low priority. On the other hand, if root access is available, sudo nice -n -5 <command> will start <command> with higher priority, which can be beneficial for important tasks that require more immediate CPU attention.

In a typical multitasking environment, processes are constantly vying for resources. Using nice can be incredibly helpful for tasks such as:

    Running background tasks: 

Assign high nice values (like 15 or 19) to resource-heavy, non-urgent background tasks, allowing your main applications to stay responsive.

    System testing: 

During system testing, you might use a low-priority nice value, ensuring it doesn’t interfere with other essential applications.

For existing processes, we have the renice command to adjust the priority dynamically. For instance, if you started a process with a low priority but need it to finish sooner, you could renice it by specifying the process ID (PID) and the new priority.

    Checking Process Niceness

To monitor the niceness of a process, use the ps command, with ps -o pid,ni,cmd -p <PID>, where the ni field displays the nice value. This command is useful when trying to identify which processes have high or low priority and adjust accordingly to manage CPU loads efficiently.

The pactl Command: Managing Audio Like a Pro

The pactl command, part of the PulseAudio suite, provides direct access to control audio devices on a Linux system. PulseAudio is the audio server in most Linux distributions, routing and controlling audio streams to and from various devices. With pactl, users can manage volume, mute/unmute devices, and reroute audio sources in real-time.

Core Concepts in pactl

Before diving into command examples, it’s important to understand the terminology PulseAudio uses for different types of devices:

    Sinks: These are audio output devices, such as speakers or headphones.
    Sources: These represent audio input devices, like microphones.
    Sink Inputs: Application outputs that direct audio to a sink (e.g., music from a media player directed to your speakers).
    Source Outputs: Application inputs from a source (e.g., an app recording from your microphone).   

    Common Applications of pactl

The ability to list, manage, and control sinks and sources through pactl provides a high level of flexibility, ideal for situations where we have multiple audio devices or need precise control over our audio settings.

    Listing Sinks and Sources

To display a list of all audio output devices, use pactl list sinks. This command shows device IDs, names, volume levels, and mute status for each sink. Similarly, pactl list sources will list all input devices. This information is crucial for identifying which device to manage or change, especially if you are working with multiple microphones or speakers.

    Adjusting Volume Levels

Setting the volume of a specific sink can be done with a command like pactl set-sink-volume <SINK_ID> 50%. This command sets the volume of the specified sink (output device) to 50%, which is often useful when you want consistent audio levels across different devices.

    Muting and Unmuting

To mute or unmute a specific sink, use pactl set-sink-mute <SINK_ID> 1 to mute and pactl set-sink-mute <SINK_ID> 0 to unmute. This feature is particularly useful for quickly silencing specific devices, such as when toggling between speakers and headphones in shared spaces or meetings.

    Redirecting Audio Streams

A standout feature of pactl is the ability to redirect or move an audio stream to a different output device. For example, if you’re playing music through your speakers but want to switch it to your headphones, you can find the sink input ID (using pactl list sink-inputs) and then use pactl move-sink-input <SINK_INPUT_ID> <SINK_ID> to reroute the audio without interrupting playback. This feature allows for seamless transitions and granular control of audio sources.

    Troubleshooting and Volume Consistency

Since PulseAudio manages all audio, sometimes devices may lose sync or behave unexpectedly. With pactl, resetting volume levels, switching devices, or reassigning streams can resolve these issues quickly. For instance, setting consistent volume levels across different outputs using set-sink-volume is a great way to ensure balanced audio performance, especially useful for users frequently switching between devices.

10. Conclusion

With the Raspberry Pi 3 Model B+, Bluetooth and BLE capabilities can unlock numerous wireless applications. However, configuring these features may require some troubleshooting. By following the steps outlined in this guide, you’ll be able to set up and manage Bluetooth and BLE on your Raspberry Pi successfully.

This guide covered both setup commands and key troubleshooting tips, allowing you to build wireless projects with confidence.


Comments

Post a Comment