Digital Guitar Effects Box

Figure 1: Diagram of Initially Proposed System

Chorus

The Chorus effect emulates the effect naturally produced by choirs or orchestras where multiple tones of slightly different frequencies are mixed. A good example of Chorus is the intro to "Come as You Are" by Nirvana.

Phaser

A Phaser effect creates a rippling quality in the sound by dividing the audio signal into two and altering the phase of one portion. This effect can be clearly heard at the beginning of "Just the Way You Are" by Billy Joel.

Flanger

The Flanger effect has been described as a "jet plane" or "spaceship" sound. Traditionally, it was implemented by recording a track on two synchronized tapes and periodically slowing the playback of one tape by pressing on the edge of its reel (the "flange"). A Flanger effect can be heard right before the bridge in "Listen to the Music" by The Doobie Brothers.

Tremolo

The Tremolo effect is a rapid, subtle variation in the volume of a passage. A good example of Tremolo is the beginning of "Born on the Bayou" by Creedence Clearwater Revival.

Vibrato

The Vibrato effect is similar to Tremolo, except that Vibrato rapidly varies the pitch of a note or passage, instead of the volume. Vibrato mimics the fractional semitone variations produced by string instrument players and singers when sustaining a note. Vibrato can clearly be heard in the guitar solo in "Samba Pa Ti" by Carlos Santana.

Wah-wah

A Wah-wah pedal sweeps the passband of a filter up and down in frequency to create its signature "wah" sound. The opening of "Voodoo Child (Slight Return)" by Jimi Hendrix is famous for its use of "wah-wah."

Delay

The Delay effect produces an echoing sound by overlaying a time-delayed duplicate onto the original signal. It is sometimes referred to as the Echo effect. Delay is employed at the beginning of "Welcome to the Jungle" by Guns N' Roses.

Reverb

The Reverb effect duplicates the sounds produced in echo chambers by creating a large number of echoes that gradually decay or fade away. Reverb is applied to the drums in "When the Levee Breaks" by Led Zeppelin.

Distortion

Distortion, or Overdrive, effects are often thought of as "gain" effects. Traditionally, they were implemented by boosting the gain of the signal so much that the voltage rails of the amplifier "clipped" the signal. This "clipping" distorts the shape of the waveform and produces overtones. Distortion produces a sound that can be described as "gritty" or "fuzzy." It is used throughout "Revolution" by The Beatles.

Figure 2: Project Enclosure for the Effect Pedal

Exploration of Real-Time Capabilities

As mentioned above, we originally wanted to implement a system capable of applying effects to audio signals in real-time. However, after some initial system development, we were unable to implement a real-time system that could process audio without an excessive amount of latency. Due to this, we settled on a more segmented framework consisting of separated system actions: recording, effect application, and playback. This framework motivated the use of the four distinct processes that will be discussed below.

We will further discuss our challenges with implementing a truly real-time system in the Testing Section.

Multi-processing Framework

The entirety of the code and programs used in the effect pedal resides in a single master program called 'effect_box.py.' This master program is structured in a multi-processing framework where individual processes can communicate using shared global variables that are specified in the main function. We identified four distinct processes that would be run within this master program: the pedal's GUI, the audio recording process, the audio playback process, and the effect-applying process. Furthermore, the global variables shared between these processes all serve one of two purposes, which are either as values representing adjustable effect parameters or as flags representing when to run certain sections of the program.

The global "effect parameter" variables are shared between only the GUI process and the effect-applying process. When the pedal is in use, the user selects the values of effect parameters via the GUI and rotary encoders. The global variables of these parameters are then updated to match the user's selection. When the effect-applying process later accesses the values of these effect parameters, the parameter values match the desired values specified by the user in the GUI.

The global "flag" variables are shared between all four processes and determine which sections of the code to run. The first of these flag variables that we implemented is a flag that determines whether the entire program should be running, named "Code_running." When this flag is set to 1, all of the four processes continue to run. When this flag is set to 0, the four processes all quit. Another flag variable we implemented is a flag that corresponds to the type of effect that the user picked to modify the audio. Flags like these are used throughout the multi-processing framework to allow the individual processes to communicate with each other.

Effects GUI Process

Our Effects GUI process was responsible for controlling the system's user interface. We decided to organize our GUI into a series of system screens that would be displayed on the PiTFT. User input (presses on the touchscreen) would allow the user to transition between the different screens and prompt the system to perform different actions. We used PyGame, which we gained experience with in previous lab assignments, to animate the system screens. A python dictionary was made for each system screen, and the value of a state variable determined which dictionary was used to animate the PiTFT screen. Figure 3 shows the state diagram we developed to control the screen transitions.

Figure 3: State Diagram for Screen Transitions

Upon startup, the system began at the Home screen. Here, the user was prompted to press a large "REC" button when he or she wanted to start recording audio input. When the user pressed the "REC" button, the Record WAV process began recording audio input, and the system transitioned to the Recording Screen. Figure 4 shows an image of the Home screen.

Figure 4: Image of Home Screen

On the Recording screen, the user had two options. The first was to press "Done," which would prompt the Record WAV process to stop and save the recording. Additionally, this would cause the system to transition to the Choose Effect screen. The second option was to press "Cancel," which would delete anything recorded by the Record WAV process and prompt the system to transition back to the Home screen. We felt this would be useful if the user was ever unhappy with the recording. Figure 5 shows an image of the Recording screen.

Figure 5: Image of Recording Screen

From the Choose Effect screen, the user could pick an effect to apply to his or her recording. He or she could choose any of the three effects we were able to implement: distortion, delay, or tremolo. When "Distortion" was pressed, the system transitioned to the Distortion Parameters screen. When "Delay" was pressed, the system transitioned to the Delay Parameters screen. When "Tremolo" was pressed, the system transitioned to the Tremolo Parameters screen. Figure 6 shows an image of the Choose Effect screen.

Figure 6: Image of Choose Effect Screen

Depending on which effect was chosen on the Choose Effect screen, the system then transitioned to one of the three effect parameter screens. On these screens, the user could see the current value of the parameter(s) for the chosen effect. By rotating the rotary encoders, the user could change parameter values, and the screen would update to the current parameter values. Inside the Effect GUI process, we defined three GPIO events, one for each rotary encoder. When a rotation was detected, one of the GPIO events would use a callback function to determine whether the rotation was clockwise or counterclockwise. If the rotation was clockwise, the corresponding parameter would be incremented. If the rotation was counterclockwise, the corresponding parameter would be decremented. Once the user was happy with the parameter value(s), he or she could press "Apply" on the screen, which would prompt the Apply Effects process to apply the correct effect to the recording. Additionally, the system would transition to the Playback screen. Figure 7 shows an image of the Delay Parameters screen.

Figure 7: Image of Delay Parameters Screen

On the Playback screen, the user had four options. The first was to press "Play Original," which triggered the Audio Playback process to begin playing the original, unmodified recording. In addition, the system transitioned to the Audio Output screen. The second option was to press "Play New Version," which prompted the Audio Playback process to begin playing the modified recording. In this case, the system would also transition to the Audio Output screen. The third option was to press "Different Effect," which caused the system to transition back to the Choose Effect screen. This functionality was useful when the user wanted to apply a different effect to the recording, after already hearing the recording with another effect applied. Applying a different effect would delete the previous modified recording and replace it with a new one. The fourth option was to press "Return Home," which prompted the system to transition back to the Home screen. This functionality was necessary when the user was finished with one recording and wanted to start a new one. Re-recording would delete the original recording and replace it. Figure 8 shows an image of the Playback screen.

Figure 8: Image of Playback Screen

On the Audio Output screen, the user was able to hear either of the recordings being played back by the Audio Playback process. When the end of the recording was reached, the Audio Playback process would loop back to the beginning and continue playing. If the user pressed "Stop," the Audio Playback process would cease playing the recording, and the system transitioned back to the Playback Screen. This made it easy for the user to compare the recordings by playing one recording, pressing "Stop," and immediately playing the other recording. Figure 9 shows an image of the Audio Output screen.

Figure 9: Image of Audio Output Screen

Record WAV Process

The audio recording process begins immediately along with the other three processes in the main function. First, this process globalizes certain constant audio stream parameters set in the beginning of the effects_box.py master program. Next, it opens an instance of PyAudio and sets up a stream to record the .wav file, using the constant parameters that were just previously globalized (these parameters include the format, sample rate, number of channels, input device index, and chunk size). Finally, an empty array named 'frames' is created. This will be used later to store individual frames of the recorded audio.

Once these parameters have been initialized once, the audio recording process idles, waiting for the global record_flag variable to be set high. When the user presses the big red "REC" button on the home screen, this record_flag variable is set high, allowing the audio recording process to enter into the actual audio recording functionality.

Once this occurs, audio input is continually read in through the open stream at the specified chunk size, at which point it is appended to the 'frames' array. This process continues until the user quits recording from the GUI and the global record_flag variable is set low. Next, the array of frames is saved to a .wav file named 'original.wav.' Afterwards, the .wav file is closed and the 'frames' array is emptied. The audio recording process then returns, waiting for the record_flag variable to be set high to record again.

Apply Effects Process

The apply effects process also begins immediately upon startup, where it first globalizes the same set of audio parameters used in the previous process. These parameters are used later in the program to save the modified .wav file in the same desired format. Next, the process specifies certain constants used in calculating each individual effect. The first effect constants are used in mapping the value of the global distortion parameter to the maximum value of the distortion threshold itself. The sample rate is then specified for use in the delay effect, where it is used in relating the delay time from seconds to frames. Finally, the global delay volume parameter is then mapped to a maximum set value.

The functions that calculate and apply each of the audio effects are then defined. Each of these functions accepts the audio file itself, written as an array of 16-bit signed integers, stored in 'signal.' These effect functions also accept certain parameters which ultimately correspond to the global effect parameter values chosen in the GUI.

The distortion calculation function parses through the array of signed 16-bit integers. If any values exceed the threshold specified by the threshold_param parameter, they are clipped and set to that threshold parameter. If the values do not exceed this threshold, they are left alone.
The delay calculation function essentially adds early frame values to later frame values. The number of frames between each frame value and when it is later added is contingent on the delay_time_param parameter. This corresponds to the time it takes to hear the echoed delay. Before the echoed frame is added onto a later frame, its volume is diminished from anywhere between 0% and 100% its original value. This decrease in volume is determined by the delay_volume_param parameter.
The tremolo calculation function splits up the array of 16 bit integers into chunks of a set length that corresponds to the tremolo_speed_param parameter. It then diminishes the volume of every other chunk by between 0% and 100% its original value. This decrease in volume is determined by the tremolo_intensity_param parameter.

Next, the apply_effects process waits for the global apply_flag variable to be set high before continuing. Once the user decides to apply an effect to the .wav file, the process calculates the aforementioned parameters. These parameters cannot be calculated earlier in the program, since they incorporate global variables shared in the multi-processing system. The process then opens up the orignal, unmodified .wav file, which is named 'original.wav.' The data in this file are converted to an array of signed 16-bit integers, named 'signal.' The apply effects process then identifies which effect function to apply to 'signal' by checking the value of the global effect_flag parameter. The new signal is then calculated using the previously defined functions and effect parameters.

Finally, the process converts the modified array of signed 16-bit integers into a .wav file. This uses the audio format parameters previously globalized at the beginning of the process, and then saves the new, modified .wav file as 'modified.wav.' The instance of PyAudio is then terminated, and the apply_flag value is set back to zero.

Audio Playback Process

The audio playback process begins at startup, and immediately defines a callback function. This callback function is used to read a single individual frame of the specified .wav file and return its value. After defining this function, the process waits for the global playback_flag value to be set high. Once this occurs, the process then checks which .wav file to play by accessing the value of the global version_flag parameter. The process then opens up the .wav file that corresponds to that parameter (either the original or modified version). Next, an instance of PyAudio is created, and an output stream is defined with the same format, channel, sample rate, etc. parameters of the .wav file. The stream is then started. For each frame of the .wav file, the previously mentioned callback function reads and returns the frame data necessary to play the audio file. The audio file plays continuously for as long as the global playback_flag value is high. Once this parameter is set low, the stream closes and the instance of PyAudio terminates.