shawn/op-pedal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Spellcheck. :-/

Browse Source
This commit is contained in:
Robin E. R. Davies
2025-07-01 21:00:24 -04:00
parent 71304ff9ec
commit ee201d280f
13 changed files with 88 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.vscode/settings.json
Vendored
+18
View File
@@ -109,16 +109,27 @@
"Alsa",
"alsactl",
"alsamixer",
"authd",
"Avahi",
"Bassman",
"Chowdhury",
"Chowdhury's",
"discursus",
"distros",
"dpkg",
"flac",
"Freeverb",
"Guitarix",
"gxplugins",
"hostapd",
"Hotspot",
"Hotspots",
"invada",
"Jatin",
"jmap",
"journalctl",
"kconfig",
"Kemperer",
"Lilv",
"midiclip",
"midisong",
@@ -128,14 +139,21 @@
"Pedalboard",
"pipedal",
"pipedal_0",
"pipedaladmin",
"pipedaladmind",
"pipedalconfig",
"pipedald",
"pipedalshutdownd",
"pipedaltest",
"pipedalui",
"rdfs",
"RTAS",
"setlist",
"stompboxes",
"ToobAmp",
"toolsets",
"urids",
"usermod",
"Writables",
"xruns"
],
docs/AboutPiPedal.md
+9 -9
View File
@@ -10,7 +10,7 @@ To get the most out of PiPedal, you need to understand a little about what's goi
{% include pageIcon.html %}
Machine Learning (Artifical Intelligence) has changed everything.
Machine Learning (Artificial Intelligence) has changed everything.
In the world of guitar effect pedals, the revolution started in 2019 when Jatin Chowdhury published [a paper](https://arxiv.org/pdf/2106.03037) describing the results of using machine learning to simulate guitar amplifier effects in real-time. To put things in perspective, LLM AIs like ChatGPT have billions of parameters. Jatin was more interested in how well AI techniques worked if you used small Neural Net models with a few thousand parameters—models small enough to run in real-time. The answer was surprisingly positive: you can use small models and get impressive results. He then proceeded to publish his source code, both for the real-time simulations and the tools used to train his models, under an open-source MIT license. This has created an avalanche of innovation.
@@ -22,33 +22,33 @@ Steven D. Atkinson has since released the Neural Amp Modeler library, which trac
Subsequently, a large open-source-minded community has devoted itself to training new Neural Net models for these libraries. The compute time required is substantial, typically requiring rented time on NVIDIA AI hardware in the cloud. Training models also requires access to the equipment being modeled. While the compute time isn't particularly expensive, it takes time and effort to record good source material and train the models, which is why a community effort is necessary. There are now hundreds of high-quality, free models for both libraries, covering everything from heavy metal amps to sublime Tweed emulations, distortion/overdrive/fuzz pedals, and even famous tube-based mixing board strips.
The quality is readily apparent and not a subtle improvement. These are amp simulations that not only sound exactly like what they're simulating but also play and feel like the amps they're emulating. We're talking about 5150 emulations that actually chug, Twin emulations with that sparkly chime that makes your ears itch, and 1962 Fender Bassmaster emulations with the warmth and forgiveness jazz players seek. (These qualities are not often found in previous-generation amp emulations).
The quality is readily apparent and not a subtle improvement. These are amp simulations that not only sound exactly like what they're simulating but also play and feel like the amps they're emulating. We're talking about 5150 emulations that actually chug, Twin emulations with that sparkly chime that makes your ears itch, and 1962 Fender Bassman emulations with the warmth and forgiveness jazz players seek. (These qualities are not often found in previous-generation amp emulations).
So let's just to put all of that in perspective, because the results of all of that have huge implications for the music industry going forward. Jatin Chowdhury's machine learning experiment escaped from the lab in 2019, and has since taken over the world. You can use his code (and derivatives thereof) for free, in guitar plugins that are availble on all major audio platforms and on all major hardware platforms, for free, and get access to a huge library of community-developed models for those plugins which are also free. All of which sound better than $1000+ stopboxes.
So let's just to put all of that in perspective, because the results of all of that have huge implications for the music industry going forward. Jatin Chowdhury's machine learning experiment escaped from the lab in 2019, and has since taken over the world. You can use his code (and derivatives thereof) for free, in guitar plugins that are available on all major audio platforms and on all major hardware platforms, for free, and get access to a huge library of community-developed models for those plugins which are also free. All of which sound better than $1000+ stompboxes.
### So Where Does PiPedal Fit In?
And now you can plug in a USB audio adapter (not free, I'm afraid) into your Raspberry Pi (also not free, but very cheap), and run those incredible amp models in realtime with low latency using PiPedal (which is also free). That isn't entirely what PiPedal started off as. But at this particular moment in time, that's what PiPedal is.
And yes, all of the easy effects (reverb, delay, chorus, flangers, modulators, phasers, etc. etc. etc) are either included with PiPedal, or are available for free as LV2 plugins that can also be downloaded from the internet. And Machine Learning plugins also provide good emulations of overdrive, fuzz pedals and other distortion effects, so that's covered. And convolution reverb and cab IR effects aren't particularly easy, but once you've coverd that, you pretty much have it all.
And yes, all of the easy effects (reverb, delay, chorus, flangers, modulators, phasers, etc. etc. etc) are either included with PiPedal, or are available for free as LV2 plugins that can also be downloaded from the internet. And Machine Learning plugins also provide good emulations of overdrive, fuzz pedals and other distortion effects, so that's covered. And convolution reverb and cab IR effects aren't particularly easy, but once you've covered that, you pretty much have it all.
But the living heart and soul of a guitar stomp box is the amp emulations, and how good they are. On Pipedal, thanks to Jatin Chowdhury's escaped monster, they are very good indeed.
### What PiPedal Is
PiPedal is a guitar stomp box implmenentation that runs on a Raspberry Pi. It provides a basic set of plugin to get you started, among are which are, notably, TooB ML (using Jatin Chowdhury's ML library) and TooB Neural Amp Modeler (using Steven Atkinson's Neural Amp Model library). PiPedal provides a basic set of LV2 plugins to get you started. Among those plugins are TooB ML (which uses the ML library), and TooB Neural Amp Modeler (which uses the Neural Amp Modeler library). PiPedal uses Linux-standard LV2 plugins, allowing you to download and install additional LV2 plugins as needed.
PiPedal is a guitar stomp box implementation that runs on a Raspberry Pi (or comparable x64 micro pcs). It provides a basic set of plugin to get you started, among are which are, notably, TooB ML (using Jatin Chowdhury's ML library) and TooB Neural Amp Modeler (using Steven Atkinson's Neural Amp Model library). PiPedal provides a basic set of LV2 plugins to get you started. Among those plugins are TooB ML (which uses the ML library), and TooB Neural Amp Modeler (which uses the Neural Amp Modeler library). PiPedal uses Linux-standard LV2 plugins, allowing you to download and install additional LV2 plugins as needed.
You access all of those plugins and configure them using PiPedal's web interface, which is important. GPUs and real-time audio effects do not get along well together. So if the user interface you use to control PiPedal is remote, it means that PiPedal can be configured to run with extraordinarily low latency, and use 80% or more of availabe CPU to run what really matters: guitar effects plugins. GPUs, by the way, are why you can't really ever get low latency on a laptop or PC. PiPedal lets you use your phone, or your tablet or maybe even your laptop to run the user interface, and let your Raspberry Pi concentrate on processing low-latency realtime audio.
You access all of those plugins and configure them using PiPedal's web interface, which is important. GPUs and real-time audio effects do not get along well together. So if the user interface you use to control PiPedal is remote, it means that PiPedal can be configured to run with extraordinarily low latency, and use 80% or more of available CPU to run what really matters: guitar effects plugins. GPUs, by the way, are why you can't really ever get low latency on a laptop or PC. PiPedal lets you use your phone, or your tablet or maybe even your laptop to run the user interface, and let your Raspberry Pi concentrate on processing low-latency realtime audio.
Unlike most other audio host applications, PiPedal runs as a daemon, whether you're logged on or not. So all you have to do is plug in your Rasberry Pi, and play - no login required.
Unlike most other audio host applications, PiPedal runs as a daemon, whether you're logged on or not. So all you have to do is plug in your Raspberry Pi, and play - no login required.
When you're playing away from home, PiPedal provides an auto-hotspot feature, which automatically brings up a Wi-Fi hotspot on your Raspberry Pi whenever Pipedal can't see your home router (or an ethernet connection, if that's how you connect to your Pi at home). So all you have to do when you're playing away from home, is power on your Raspberry Pi, pull out your phone or tablet or laptop, and you're all ready to go.
But most importantly PiPedal sounds great because it leverages the work of Jatin Chodhury, and Steven D. Atkinson. And in the end, whether it sounds great is all that really matters. So please do spend some serious time with the TooB ML and TooB Neural Amp Modeler plugins.
But most importantly PiPedal sounds great because it leverages the work of Jatin Chowdhury, and Steven D. Atkinson. And in the end, whether it sounds great is all that really matters. So please do spend some serious time with the TooB ML and TooB Neural Amp Modeler plugins.
That's what PiPedal is.
PiPedal doesn't come with a lot of models, or a lot of effects. It is a platform. The TooB ML plugin (included with Pipedal) includes Jatin Chowdhury's original amp models, which sound pretty good, but are nowhere near as good as current-generation models. So download some models for TooB ML. And TooB Neural Amp Modeler doesn't come with any models at all. So download some models for TooB NAM as well. And PiPedal comes with a very bare minimum set of LV2 effects, just to get you started. The plugins it does have are (I think) good and useful plugins. TooB Freeverb is there because Freeverb is my favorite goto reverb even in a world filled with convolution reverbs; a convolution reverb, because not everyone agrees; a good flanger (which sounds unreasonable fabulous in stereo); a sensible no-nonsense delay; a decent chorus; a couple of cab simulator effects and a few others. So if you'e looking for anything but bare basics, download some LV2 plugins as well.
PiPedal doesn't come with a lot of models, or a lot of effects. It is a platform. The TooB ML plugins (included with Pipedal) includes Jatin Chowdhury's original amp models, which sound pretty good, but are nowhere near as good as current-generation models. So download some models for TooB ML. And TooB Neural Amp Modeler doesn't come with any models at all. So download some models for TooB NAM as well. And PiPedal comes with a very bare minimum set of LV2 effects, just to get you started. The plugins it does have are (I think) good and useful plugins. TooB Freeverb is there because Freeverb is my favorite goto reverb even in a world filled with convolution reverbs; a convolution reverb, because not everyone agrees; a good flanger (which sounds unreasonable fabulous in stereo); a sensible no-nonsense delay; a decent chorus; a couple of cab simulator effects and a few others. So if you'e looking for anything but bare basics, download some LV2 plugins as well.
--------
[Up](Documentation.md) | [Installing PiPedal >>](SystemRequirements.md)
docs/Architecture.md
+4 -4
View File
@@ -16,7 +16,7 @@ Fig 1. PiPedal Architecture.
HTML connections to the server are made over port 80 in production, or port 8080 when debugging.
When debugging React code, an instance of the React development servier must be started. The development server serves static content on port 3000. To
When debugging React code, an instance of the React development server must be started. The development server serves static content on port 3000. To
start the development server `cd` to the react directory, and run `./start`.
Figure 2 shows the architecture of PiPedal when running with the React debug server.
@@ -24,7 +24,7 @@ Figure 2 shows the architecture of PiPedal when running with the React debug ser
Fig 2. PiPedal architecture when using the React development server.
To debug React code, connect to the development server, on port 3000, with Chrome. To access the Chrome debugger, press F12. You should be able to browse the React source files from within the Chrome debugger. Load the typescript source file in the Chrome debugger. Once you have done that, you should be able to debug the Typescript code directly. Chrome will automaticallyt detect that it is connected to a React debug server, and will automatically download symbol and map files from the React development server.
To debug React code, connect to the development server, on port 3000, with Chrome. To access the Chrome debugger, press F12. You should be able to browse the React source files from within the Chrome debugger. Load the typescript source file in the Chrome debugger. Once you have done that, you should be able to debug the Typescript code directly. Chrome will automatically detect that it is connected to a React debug server, and will automatically download symbol and map files from the React development server.
When using the React development server, the web client can be configured to make web socket connections to either a debug version of the server, with a web server at port 8080, or a production server, with a web server at port 80. When running with the React development server, edit
@@ -40,9 +40,9 @@ When using the React development server, the web client can be configured to mak
}
```
The `debug` value determines whether the web application will disable background context menus. Enabling context menus allows you to select the 'Inspect' menu item, which is useful when debuging HTML content.
The `debug` value determines whether the web application will disable background context menus. Enabling context menus allows you to select the 'Inspect' menu item, which is useful when debugging HTML content.
The `fakeAndroid` setting determines whether the web application will use touch-interface interactions instead of mouse-interface interactions. There are a number of subtle adaptations the web app makes to accomodate touch interfaces.
The `fakeAndroid` setting determines whether the web application will use touch-interface interactions instead of mouse-interface interactions. There are a number of subtle adaptations the web app makes to accommodate touch interfaces.
Note that, when connecting directly to the pipedald web server on port 80, or port 8080, the web server intercepts all requests to documents in the `var` directory, including the `var/config.json` file, and instead returns data that reflects the configuration of the pipedald service. The contents of the `public/var` directory will be completely ignored. The `debug` setting will be true if the pipedald service is a Debug build, and will be false if the pipedald service is a Release build. The `fakeAndroid` setting will always be false.
docs/AudioLatency.md
+3 -3
View File
@@ -16,7 +16,7 @@ does not require 3 audio buffers to work efficiently.
PiPedal provides the pipedal_latency_test utility to measure actual round-trip audio latency. You must temporarily disable pipedal (`sudo systemctl stop pipedal`), and connect the left audio output of your audio device to the left audio input of your audio device with a guitar cable to use this test.
The following table shows measured round-trip audio latencies for a MOTU M2 external USB adapter running on Raspbery Pi OS with a 48 KHz sample rate. You can use these figures as a rough guideline; but actual round-trip audio latency will depend on the audio device you are using.
The following table shows measured round-trip audio latencies for a MOTU M2 external USB adapter running on Raspberry Pi OS with a 48 KHz sample rate. You can use these figures as a rough guideline; but actual round-trip audio latency will depend on the audio device you are using.
<table align='center'>
<tr><td></td><td colspan=3>Buffers</td></tr>
@@ -30,7 +30,7 @@ The following table shows measured round-trip audio latencies for a MOTU M2 exte
</table>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Table 1: Delay in samples/delay in ms on MOTU M2 @ 48KHz.
Make sure your system is fully updated. A kernel version greater than 5.15 is recommened, as Linux 5.15 is known to contain patches that
Make sure your system is fully updated. A kernel version greater than 5.15 is recommend, as Linux 5.15 is known to contain patches that
provide significant performance improvements for USB audio devices. Version 5.10 provides patches that provide broad support for
USB audio adapters. Kernel versions prior to 5.10 provide limited support for a limited number of mostly obsolete USB adapters.
PiPedal will run on kernel versions less than 5.10, but may not provide robust, stable audio.
@@ -41,7 +41,7 @@ RT_PREEMPT realtime kernels (when available) are preferred but not required. How
The Ubuntu Studio installer will install a realtime kernel if there is one available. But -- at least for Ubuntu 21.04 -- there is no stock RT_PREEMPT kernel for ARM aarch64.
On a Raspberry Pi 4 device, Wi-Fi, USB 2.0, USB 3.0 and SD Card access are performed over separate buses (which is not true for previous versions of Raspberry Pi). It's therefore a good idea to ensure that your USB audio device is either the only device connected to the USB 2.0 ports, or the only device connected to the UBS 3.0 ports. There are theoretical advantages to USB 3.0 over USB 2.0 for USB audio; but I don't beleive there are currently any USB audio devices that take advanage of USB 3.0 features. If in doubt, use a UBS 3.0 ports; if there are problems, of if you have a high-speed drive attached to a USB 3.0 port, use a UBS 2.0 port.
On a Raspberry Pi 4 device, Wi-Fi, USB 2.0, USB 3.0 and SD Card access are performed over separate buses (which is not true for previous versions of Raspberry Pi). It's therefore a good idea to ensure that your USB audio device is either the only device connected to the USB 2.0 ports, or the only device connected to the UBS 3.0 ports. There are theoretical advantages to USB 3.0 over USB 2.0 for USB audio; but I don't believe there are currently any USB audio devices that take advantage of USB 3.0 features. If in doubt, use a UBS 3.0 ports; if there are problems, of if you have a high-speed drive attached to a USB 3.0 port, use a UBS 2.0 port.
Network traffic does not seem to adversely affect USB audio operations on Raspberry Pi 4 (which isn't true on previous versions of Raspberry Pi, which use a common bus for network and USB devices). Filesystem activity does affect USB audio operation on Raspberry Pi OS, even with an RT_PREEMPT kernel; but interestingly, filesystem activity has much less effect on USB audio on Ubuntu 21.04, even on a plain PREEMPT kernel.
docs/BuildPrerequisites.md
+14 -15
View File
@@ -3,25 +3,24 @@
Run the following commands to install build tools required by the PiPedal build.
# install CMake
sudo apt updatee
sudo apt update
sudo apt upgrade
sudo apt install -y cmake ninja-build build-essential g++ git
The PiPedal build process also requires version 12 or later of `node.js`. Type `node --version` to see if you have a version
of `node.js` installed already. Otherwise run the following commands as root to install the v14.x lts version of `node.js`:
`
of `node.js` installed already. Otherwise run the following commands as root to install a current version of version of `node.js`:
sudo apt install nodejs npm curl
If your distribution doesn't provide a suitable version of nodejs, you can install the current LTS version of nodejs
with
# install NodeJS latest LTS release.
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs npm
If your distribution doesn't provide a suitable version of nodejs,
please refer to the `node.js` website for instructions on [how to install the latest version of `node.js`](https://nodejs.org/en/download) directly.
Run the following commands to install dependent libraries required by the PiPedal build.
sudo apt update
sudo apt upgrade
sudo apt install -y liblilv-dev libboost-dev \
libsystemd-dev catch libasound2-dev uuid-dev \
authbind libavahi-client-dev libnm-dev libicu-dev \
@@ -37,12 +36,12 @@ If you are using Visual Studio Code, install the following Extensions:
- C/C++ Extension Pack (Microsoft).
- CMake Tools (Microsoft)
Clone the rerdavies/pipdal package from github. Use the source control tools from Visual Studio Code, or
cd ~/src # or whereever you keep your source repositories.
git clone https://github.com/rerdavies/pipedal.git
In the project root, run the following commands to initialze and update pipedal submodules. These steps
Clone the `rerdavies/pipedal` package from github. Use the source control tools from Visual Studio Code, or
cd ~/src # or wherever you keep your source repositories.
git clone https://github.com/rerdavies/pipedal.git
In the project root, run the following commands to initialize and update PiPedal submodules. These steps
must be performed even if you used Visual Studio Code to initially install the project.
cd ~/src/pipedal
docs/BuildingPiPedalFromSource.md
+3 -3
View File
@@ -5,13 +5,13 @@ page_icon: img/Compiling.jpg
{% include pageIcon.html %}
PiPedal has only been tested on Raspberry Pi OS, and Ubuntu 24.x, but should run with some modifications on most Linux distributions. Pull requests to correct problems with building PiPedal on other versions of Linux are welcome. However, getting build pre-requisites installed on non-Debian-derived Linux distrubutions (distros that don't use `apt`) will be challenging.
PiPedal has only been tested on Raspberry Pi OS, and Ubuntu 24.x, but should run with some modifications on most Linux distributions. Pull requests to correct problems with building PiPedal on other versions of Linux are welcome. However, getting build pre-requisites installed on non-Debian-derived Linux distributions (distros that don't use `apt`) will be challenging.
To build and debug PiPedal using Visual Studio Code, you need 8GB of memory. You can build PiPedal with 2GB of memory.
If your Pi is short on memory, you _can_ run VSCode on laptop or desktop and configure VSCode to connect to your Raspberry PI using SSH connections. You can definitely build PiPedal using remote SSH connections on a 6GB Ubnutu VM; and can probably build Pipedal using SSH connections on a 4GB Raspberry Pi, as long as you are careful.
If your Pi is short on memory, you _can_ run VSCode on laptop or desktop and configure VSCode to connect to your Raspberry PI using SSH connections. You can definitely build PiPedal using remote SSH connections on a 6GB Ubuntu VM; and can probably build Pipedal using SSH connections on a 4GB Raspberry Pi, as long as you are careful.
As a last resort, you be able to configure VSCode and/or CMake to crosss-compile PiPedal on a laptop or desktop computer; but installing build dependencies when cross-compiling will be extremely challenging. This is not a scenario that we can provide support for.
As a last resort, you be able to configure VSCode and/or CMake to cross-compile PiPedal on a laptop or desktop computer; but installing build dependencies when cross-compiling will be extremely challenging. This is not a scenario that we can provide support for.
docs/ChoosingAUsbAudioAdapter.md
+3 -3
View File
@@ -13,13 +13,13 @@ Cheap USB audio adapters, claim to to support 24-bit audio, and happily provide
You will get decent results; but not great results. Stepping up to a more expensive USB adapter dramatically improves the quality of signal you're going to get. With a decent USB audio adapters, some of the state-of-the art Machine Learning plugin produce results that are as good as or better the Helix or Kemperer amp emulations.
I think it's worthwhile, at this point, to make a brief discursus into the state of the art when it comes to machine learning models of guitar amps. There are two major Machine Learning amp simulators that are in the public domain. Jatin Chowdhury produced some of the first really impressive Machine Learning amp simulators (I beleive) as part of his PhD thesis. Jatin Chowdhury's ML amp simulation library (which was graciously provided under an open-source MIT license) forms the core of the ToobML plugin included with PiPedal. Steven Atkins' Neural Amp Modeler library (also provided under an MIT license) is the other major ML implementation, that implements a variety of Machine Learning algorithms that have been developed since Jatin Chowdhury's initial publication of his results. TooB Neural Amp Modeler uses Steven Atkins' Neural Amp Modeler library. And both have large community-developed libaries of amp models. The quality of amp simulations produced by both of these libraries is breathtaking. As I said previously, as good as or better than Helix or Kemperer amp emulations.
I think it's worthwhile, at this point, to make a brief discursus into the state of the art when it comes to machine learning models of guitar amps. There are two major Machine Learning amp simulators that are in the public domain. Jatin Chowdhury produced some of the first really impressive Machine Learning amp simulators (I believe) as part of his PhD thesis. Jatin Chowdhury's ML amp simulation library (which was graciously provided under an open-source MIT license) forms the core of the ToobML plugin included with PiPedal. Steven Atkins' Neural Amp Modeler library (also provided under an MIT license) is the other major ML implementation, that implements a variety of Machine Learning algorithms that have been developed since Jatin Chowdhury's initial publication of his results. TooB Neural Amp Modeler uses Steven Atkins' Neural Amp Modeler library. And both have large community-developed libraries of amp models. The quality of amp simulations produced by both of these libraries is breathtaking. As I said previously, as good as or better than Helix or Kemperer amp emulations.
But to get Helix-quality (or better) results, you need a good USB adapter. For amp simulators, particulary, every extra bit of input signal is precious.
But to get Helix-quality (or better) results, you need a good USB adapter. For amp simulators, particularly, every extra bit of input signal is precious.
I personally use and recommend the Motu M2 USB audio adapter, although there are plenty of other pro-quality audio adapters that will probably work as well. Although, the MOTU devices are -- in my experience, exceptional. Check the specs carefully, signal-to-noise-ratio is what matters, not bits of data. Cheaper USB audio adapters that sell for less than US$70 will almost certainly not provide adequate signal-to-noise ratio for best results, and invariably won't provide S/N ratio specs for very very good reasons.
Ideally, you want a USB adapter that provides an input volume knob, and an instrument-level input jack, and it's enormously helpful to have a VU meter to display input signal level to the device. Line-level or RCA jacks will have the wrong input impedence, and that has strange effects when 20 feet of guitar cable and tone controls that are designed for instrument-level impedance are involved. For best results, you want the input signal to be as high as possible without clipping. Clipped input signals sound horrible. And every db below "as high as possible" brings up the noise floor. Which is why a VU meter on the
Ideally, you want a USB adapter that provides an input volume knob, and an instrument-level input jack, and it's enormously helpful to have a VU meter to display input signal level to the device. Line-level or RCA jacks will have the wrong input impedance, and that has strange effects when 20 feet of guitar cable and tone controls that are designed for instrument-level impedance are involved. For best results, you want the input signal to be as high as possible without clipping. Clipped input signals sound horrible. And every db below "as high as possible" brings up the noise floor. Which is why a VU meter on the
USB adapter is helpful.
If you don't have an audio adapter with a VU meter, pay close attention to the input VU meter of the first effect in your guitar effect chain. That will indicate the signal level coming into the USB adapter. Ideally, you want the value peaking solidly in the yellow range of the VU meter, and NEVER going red.
docs/CommandLine.md
+1 -1
View File
@@ -5,7 +5,7 @@ page_icon: img/commandline.jpg
## Command-Line Configuration of PiPedal
The pipedalconfig program can be used to modify configuration of PiPedal from a shell command line. Run 'pipedalconfig --help' to view
available configuration commands, some of which are not avaialbe from the web interface. For example, you can change the port number
available configuration commands, some of which are not available from the web interface. For example, you can change the port number
of the Web App HTTP server if you need to, using pipedalconfig.
Things you can do with pipedalconfig:
docs/Debugging.md
+19 -25
View File
@@ -31,21 +31,21 @@ or
pipedalconfig -stop #Stops the Jack service as well.
Although not strictly neccesary, you should probably add your login account to the pipedal_d group.
Although not strictly necessary, you should probably add your login account to the pipedal_d group.
sudo usermod -a -G pipedal_d *youruserid*
This will allow you to run `pipedald` under the debugger of your choice using the
same /etc/pipedal and /var/pipedal directories as an instance of `pipedal` running
under systemd. Note that when running under systemd, `pipedald` runs under an unprivileged
`piedal_d` service account, and relies it's group (also 'pipedal_d`) in order to access its
`pipedal_d` service account, and relies it's group (also 'pipedal_d`) in order to access its
data files, and to communicate with the `pipedaladmin` service, which does run with root
privileges when `pipedald` needs to perform operations that do required root privileges (e.g. shutdown/reboot and starting and stopping WiFi services).
For what it's worth, `pipedaldmin` is virtually undebuggable, becuase it does require root privileges to run.
If you really _must_ debug pipedaladmin, you can fire up a sudo isntance of Visual Studio Code
and attach to the running daemon process. But running program as large as VS Code with root privileges
is a dangerous process, that VS Code firmly (and righfully) complains about. And configuring
For what it's worth, `pipedaladmin` is virtually un-debuggable, because it does require root privileges to run.
If you really _must_ debug pipedaladmin, you can fire up a sudo instance of Visual Studio Code
and attach to the running daemon process. But running program as large as VS Code with root privileges
is a dangerous process, that VS Code firmly (and rightfully) complains about. And configuring
VSCode to run with root privileges as a painful process. Avoid if you can.
The pipedald service will run with or without the pipedaladmind service, but some operations (shutdown, reboot,
@@ -58,13 +58,18 @@ vite/React components. But while debugging, it is much more convenient to use th
React sources, and configure pipedald to serve only the websocket.
Note that a debug instance of `pipedald` cannot bind to port 80, since that requires either root privileges or
access to port 80 via `authd`. So you will have to configure the debug isntance of `pipedald`'s web server to
bind to port 8080 instead. The react server will serve the web applicaton on port 3000, so you will point your web
browser to `raspberrpi:3000`. And you will then need to configure the react application to make web socket
connection on port 8080 (where pipedald provides all dynamic content in the web app).
access to port 80 via `authd`. So you will have to configure the debug instance of `pipedald`'s web server to
bind to port 8080 instead. The react server will serve the web application on port 8080, so you will point your web
browser to `localhost:8080`. And you will then need to configure the react application to make web socket
connection on port 8080 (where pipedald provides all dynamic content in the web app). Note that the pipedald service
serves the vite/react web app as compiled into /etc/pipedal/react directory, and the debug build of pipedal does not
(by default) build the vite/react web app sources. Normally, you will use the vite/react debug server when
you are debugging. However, when using the vite/react debug server, the PiPedal client application will
use the pipedald web server on port 8080 to provide dynamic content (e.g. the web socket connect, and various
pieces of dynamic content served out of the `http://localhost:8080/var` URL and children thereof.
You may find it convenient to reconfigure the systemd intances of `pipedald` to bind to port 8080 as well.
That will allow the react server to point clients to either a debug instance or the systemd instance of `pipedald`
You may find it convenient to reconfigure the systemd instance of `pipedald` to bind to port 8080 as well.
That will allow the vite/react debug server to point clients to either a debug instance or the systemd instance of `pipedald`
depending, depending on which instance of pipedald is currently running. Run the following command to
make the systemd instance of `pipedald` bind to port 8080 instead of port 80:
@@ -96,16 +101,6 @@ The React app will display the message "Error: Failed to connect to the server",
...
}
Setting socket_server_address to "*" configures Browers clients to make web socket connections on the same
IP address they used to load the web app in the first place. If you set it to a specific address, the web app
will attempt to establish a websocket connection son that specific address instead. (Not sure what that's useful
for, but it's there if you ever need it). When running under systemd, Pipedal usually redirects browser clients
to an IPv4 address if the initial connection was made via IPv6, since long-lasting IPv6 websocket connections
are problematic, and IPv6 link-local adresses (which you sometimes get from mDNS servers) are completely toxic.
The React debug server does not do that (since the app configuration that clients get from the
React server is static). If you're connecting using mDNS (via 'raspberrypi:3000', for example), you could
end up connectiong to the React web app on an IPv6 address. So it might be useful for that. The easier solution
is probably just to use an explicit IPv4 address when you connect to the React debug server.
The original development for this app was done with Visual Studio Code. And it's probably easiest to go with the flow when building
or debugging PiPedal. Open the root project directory in Visual Studio Code, and VSCode will automatically detect the CMake build
@@ -115,12 +110,11 @@ and to settle down a bit.
Once VSCode has configured itself, build and debug commands are available on the CMake toolbar at the
bottom of the Visual Studio Code window. (Or in the CMake tab on the left-hand side of VSCOde if you have
chosen not to configure the CMake add-on to make CMake controls visible on the bottom toolbar).
Choose your compiler toolset. PipPedald sort of builds on a Clang toolset; although Clang may give warnings. But it's usually
not significantly worse than building on a newly released version fo GCC. It's probably best to do your first build with the build
Choose your compiler toolset. PiPedal will also build on a Clang toolsets, although that is a feature that gets tested infrequently, to be honest. It's probably best to do your first build with the build
variant set to RelWithDebugInfo. If you can get to the point that you can install Pipedal using ./install.sh, then that will
ensure that all the various configuration files that Pipedal requires are deployed in all the right places, whether the services
run properly or not. Check system logs using `journalctl -b0 | less` to see how well your newly built version of
Pipedal is doing, and stop systemd services as neccesary and appropriate.
Pipedal is doing, and stop systemd services as necessary and appropriate.
Set the build variant to debug. Set the debug target to "pipedald". Click on the Build button to build the app. Click on the Debug button to launch a debugger.
docs/Installing.md
+2 -2
View File
@@ -31,9 +31,9 @@ You MUST use `apt-get`. `apt` will not install downloaded packages; and `dpkg -i
On Raspberry Pi OS, if you have a graphical desktop installed, you can also install the package by double-clicking on the downloaded package in the File Manager.
If you are using Ubuntu, there are additional post-installation steps you must take to reconfigure the Ubuntu kernel to
provide support for low-latency real-time audio. Proced to [PiPedal support for Ubuntu](Ubuntu.md).
provide support for low-latency real-time audio. Proceed to [PiPedal support for Ubuntu](Ubuntu.md).
If you are using Raspberry Pi OS, procede directly to [Configuring PiPedal after Installation](Configuring.md). If
If you are using Raspberry Pi OS, proceed directly to [Configuring PiPedal after Installation](Configuring.md). If
you are using Ubuntu, there are additional post-installation steps you must take to reconfigure the Ubuntu kernel
to provide support for low-latency real-time audio.
docs/Snapshots.md
+6 -6
View File
@@ -11,12 +11,12 @@ You can create up to six snapshots for any given preset. A snapshot differs from
{% include pageIcon.html %}
- Switching betwen snapshots does not reload the plugins you are using. Snapshots contain only control values.
- Switching between snapshots does not reload the plugins you are using. Snapshots contain only control values.
- Because effects are not reloaded, you won't get discontinuities in the output of effects with long tails (like reverb effects, for example).
- Loading a snapshot is much faster than loading a preset, because new plugins don't have to be created.
- You can configure PiPedal to switch between snapshots in response to MIDI messages from a MIDI footcontroller or other device.`
- You can configure PiPedal to switch between snapshots in response to MIDI messages from a MIDI foot controller or other device.`
Snapshots are useful if you have a USB or MIDI footswitch controller. You can configure PiPedal to switch between snapshots when you step on buttons on your footswitch controller. To configure MIDI bindings for snapshots, select <b><i>Settings</i></b> from the main menu, and tap on <b><i>System MIDI bindings</i></b>.
Snapshots are useful if you have a USB or MIDI foot controller. You can configure PiPedal to switch between snapshots when you step on buttons on your foot controller. To configure MIDI bindings for snapshots, select <b><i>Settings</i></b> from the main menu, and tap on <b><i>System MIDI bindings</i></b>.
But snapshots are equally useful when you are using PiPedal's <b><i>Performance View</i></b>. To access the <b><i>Performance View</i></b> click on the <b><i>Performance View</i></b> menu item in the main PiPedal menu.
@@ -25,7 +25,7 @@ But snapshots are equally useful when you are using PiPedal's <b><i>Performance
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;PiPedal's Performance View
Note how PiPedal has been configured to use <i>banks</i> as containers for songs in a set list. Each song in the setlist gets its own preset; and then snapshots are used to change controls for the preset being used in each song. As an example, the only difference between <i>Chorus</i> and <i>Chorus + Phaser</i> snaphots is whether the Phaser plugin is bypassed or not. You are of course, free to arrange your own banks and presets any way you want. But if you have a complex repertoire of songs that you play regularly, this is a good way to arrange your preset: setlists go into banks; songs go into presets; and then you use snapshots to switch between settings used in the same song.
Note how PiPedal has been configured to use <i>banks</i> as containers for songs in a set list. Each song in the setlist gets its own preset; and then snapshots are used to change controls for the preset being used in each song. As an example, the only difference between <i>Chorus</i> and <i>Chorus + Phaser</i> snapshots is whether the Phaser plugin is bypassed or not. You are of course, free to arrange your own banks and presets any way you want. But if you have a complex repertoire of songs that you play regularly, this is a good way to arrange your preset: set lists go into banks; songs go into presets; and then you use snapshots to switch between settings used in the same song.
@@ -47,9 +47,9 @@ As a general rule, it's best to get the structure (which plugins are loaded, and
Each preset has its own set of preset control settings which are independent of the control settings in each snapshot. But all share the same plugin structure (which plugins are loaded, and how they are connected together).
When you click the edit button in the Peformance View, you are editing control settings associated with the snapshot. When you press the back button from the snapshot editor, control settings for that snapshot are saved immediately. Saved control settings for the preset are not modified. You can avoid saving snapshot control settings by pressing the Cancel icon button (X) at the end of the toolbar for the snapshot editor. You cannot change the structure of the plugins in the preset to which snapshots belong from within the Snapshot editor. Nothing you do in the snapshot editor will affect the saved control values for the currently loaded preset.
When you click the edit button in the Performance View, you are editing control settings associated with the snapshot. When you press the back button from the snapshot editor, control settings for that snapshot are saved immediately. Saved control settings for the preset are not modified. You can avoid saving snapshot control settings by pressing the Cancel icon button (X) at the end of the toolbar for the snapshot editor. You cannot change the structure of the plugins in the preset to which snapshots belong from within the Snapshot editor. Nothing you do in the snapshot editor will affect the saved control values for the currently loaded preset.
Things are different when you are editing presets in the main PiPedal page. Changes to preset controls are not saved until you press the Save button. And you can make structural changes. When you make structural changes to the preset, you may also affect the control settings included in each snapshot. You can move plugins around freely. Snapshot controls will still apply to the plugin even if it has moved. But if you remove a plugin, the settings for that plugin in each snapshot will be removed. Even if you re-add a new instance of of the same plugin, settings in snapshots will not be remembered. And if you add a plugin, selecting a snapshot will set controls for the new plugin to default values (not the values of the controls in the main preset). So as a general rule, it's best to get the structure of a prest more-or-less settled before you start creating snapshots.
Things are different when you are editing presets in the main PiPedal page. Changes to preset controls are not saved until you press the Save button. And you can make structural changes. When you make structural changes to the preset, you may also affect the control settings included in each snapshot. You can move plugins around freely. Snapshot controls will still apply to the plugin even if it has moved. But if you remove a plugin, the settings for that plugin in each snapshot will be removed. Even if you re-add a new instance of of the same plugin, settings in snapshots will not be remembered. And if you add a plugin, selecting a snapshot will set controls for the new plugin to default values (not the values of the controls in the main preset). So as a general rule, it's best to get the structure of a preset more-or-less settled before you start creating snapshots.
--------
docs/UsingLv2Plugins.md
+4 -3
View File
@@ -10,14 +10,15 @@ To get you started, PiPedal comes with a basic set of plugins from the ToobAmp p
LV2 Plugins are available from a wide variety of sources. Some are available through apt installs; others can be downloaded from a variety places on the web. Some are available through github, and some even require you to build the plugins yourself. Pipedal will automatically detect freshly installed LV2 plugins. New plugins should show up in the list of available plugins a few seconds after the install completes. You don't need to restart PiPedal after installing a new plugin.
A good place to get started is the [PatchStorage](https://patchstorage.com/platform/lv2-plugins/) website. PatchStorage provides hundreds of LV2 plugins that have been precompiled and are readty to install on Raspberry Pi. To see LV2 plugins that are specifically for Raspberry Pi on PatchStorage, click on the `Target` dropdown button and select `rpi-aarch64`.
A good place to get started is the [PatchStorage](https://patchstorage.com/platform/lv2-plugins/) website. PatchStorage provides hundreds of LV2 plugins that have been precompiled and are ready to install on Raspberry Pi. To see LV2 plugins that are specifically for Raspberry Pi on PatchStorage, click on the `Target` dropdown button and select `rpi-aarch64`.
Here is a brief list of other particularly recommended plugin collections.
| Collection | To Install | Description |
|---------------------------------|---------------------------------------|------------------|
| [Guitarix](https://guitarix.org) ★★★☆☆ | `sudo apt install guitarix-lv2` | A large collection of guitar amplifiers and effects. |
| [GxPlugins](https://github.com/brummer10/GxPlugins.lv2) ★★★★★ | `sudo apt install gxplugins` | Additional amps and effects from the Guitarix collection |
| [Guitarix](https://guitarix.org) ★★★☆☆ | `sudo apt install guitarix-lv2` | A large collection of guitar amplifiers and effects. Prior to the advent of neural network amplifier emulations, Guitarix was the go-to source for open-source amp modeling.|
| [GxPlugins](https://github.com/brummer10/GxPlugins.lv2) ★★★★★ | `sudo apt install gxplugins` | Additional amps and effects from the the principle developer of Guitarix, many of which are significantly superior to the original Guitarix plugins. Most of these plugins
use circuit simulation to directly model actual original circuits. The results are uniformly excellent.|
| [DPF Plugins](https://github.com/DISTRHO/DPF-Plugins) ★★★★★ | `sudo apt install dpf-plugins-lv2` | Useful and interesting guitar effect plugins. Bit crusher, pitch shift, reverbs, 3-band EQ and more. |
| [MDA Plugins](http://drobilla.net/software/mda-lv2.html) ★★★★☆ | `sudo apt install mda-lv2` | 36 high-quality plugs |
| Invada Studio Plugins ★★★☆☆ | `sudo apt install invada-studio-plugins-lv2` | Delays, distortion, filters, phaser, reverb |
docs/WhichLv2PluginsAreSupported.md
+2 -2
View File
@@ -9,9 +9,9 @@ following conditions:
- Must be remotely controllable (no hard dependency on GUI-only controls), which is true of all but a tiny minority of LV2 plugins.
If you install a new LV2 plugin, PiPedal will detect the change and make it available immediately. Wait a few seconds, and the newly-installed plugin should show up in the list of avaialable plugins.
If you install a new LV2 plugin, PiPedal will detect the change and make it available immediately. Wait a few seconds, and the newly-installed plugin should show up in the list of available plugins.
PiPedal does all plugins to use custom user interfaces. However, we would be pleased to collaborate with developers who need more than the basic set of controls. Please contact rerdaves at gmail.com for further details.
PiPedal does not currently allow plugins to provide custom user interfaces; it displays controls that are declared by the LV2 plugin without customization. In practice, this means that LV2 plugins with simple sets of controls work well, but those with complex sets of controls can be difficult to use. However, we would be pleased to collaborate with developers who need more than the basic set of controls. This is a feature set that Pipedal needs to address, so we would be happy to collaborate with other developers on this. Please contact rerdavies at gmail.com for further details.
--------
[<< Using LV2 Audio Plugins](UsingLv2Plugins.md) | [Up](Documentation.md) | [BuildingPiPedal from Source >>](BuildingPiPedalFromSource.md)