logo elektroda
logo elektroda
X
logo elektroda
Advanced Search
logo elektroda

Digital guitar multi-effect

Kwarcu 4860 16

TL;DR

  • Builds a digital guitar multi-effects prototype for the STM32F746G-DISCO development board, using its audio I/O and touch display as the user interface.
  • The software uses C++17, MVC separation, and event-driven RTOS queues, with audio processing handled in double-buffered 128-sample blocks.
  • The audio path runs at 24-bit/48kHz, and the block size adds about 6 ms of input-to-output delay.
  • Six effects work: tremolo, echo/delay, chorus, reverb, overdrive, and cab sim, with chain order selectable from the menu.
  • It remains a concept/prototype rather than a stage-ready pedal, and planned additions include a tuner, presets, a vocoder, custom panels, and footswitch support.
Generated by the language model.
ADVERTISEMENT
Treść została przetłumaczona polish » english Zobacz oryginalną wersję tematu
Report a violation of the law
Reply Cool? Ranking DIY | New topic
Notify about new articles
📢 Listen (AI):
  • STM32F746G-DISCO development board with a display showing the text GMFX and visible audio and network cables.

    Hi

    I`ve wanted to make my own digital multi-effect for electric guitar for a long time. I couldn`t get around to it for a long time due to various things, but it`s finally here. My project only concerns software for the ready-made STM32F746G-DISCO development board. It is a concept/prototype of a device rather than a ready-made device that can be taken on stage and played.

    What is this?

    For those who don`t know, a guitar effect is a device (or software) used to modify a guitar`s signal to obtain a characteristic sound. Such effects may be based solely on analog electronics, but they can also be achieved using digital signal processing, either on a microcontroller or in computer software.

    How it`s working?

    Below is a short video briefly showing how the device works. I add three effects there: overdrive, cab sim and reverb and then I play a short melody. An electric guitar is plugged directly into the multi-effects input and its output is connected to a regular portable speaker. Later, separate audio samples for each effect will appear in the description.





    Equipment

    I had no plans to build a dedicated hardware platform for this purpose, because I already had a development board with everything necessary, and I was more interested in signal processing algorithms. Therefore, as I mentioned earlier, the project works on the STM32F746G-DISCO board. From the user`s point of view, the audio line input and output as well as the graphic touch display are important here.

    Software

    It will be difficult for me (and I don`t want) to describe the code in detail here, so I will summarize it to the most important things. The project is written in C++17. The application code is separated from the hardware and RTOS using abstraction layers. We`ll see if I did it right when I need to move the code to something else ;) . In addition, the application is written in the MVC (Model-View-Controller) pattern to achieve separation between the main modules. Model includes an effects processor with algorithms, view contains everything related to the display and interaction with the user a controller is the intermediary between the two. Thanks to this, you can easily add another module, for example view where interaction with the user and device control will take place via e.g. a terminal. The mentioned modules communicate using events (event-driven), the mechanism of which is based on RTOS queues.

    The source code is on mine github , a project created in Eclipse.

    Effects

    Currently, six popular guitar effects work: tremolo, echo/delay, chorus, reverb, overdrive and cab sim (speaker cabinet simulator). Effects can be added to the processing "chain" in any order from the menu. Audio signal processing is double-buffered and takes place in blocks, where the size of one block is 128 samples. The block size translates directly into the delay between input and output, which is approximately 6ms. Digital audio parameters are 24bit/48kHz.

    In the following description of the effects, in a "pathological" way, I will summarize the basics of their operation (and for details, please refer to the literature provided at the end). The included audio samples contain a pure guitar signal at the beginning, and only in the second half the effect is active.

    Tremolo

    This is probably the simplest effect, which involves modulating the amplitude of the guitar signal using a low-frequency oscillator.

    tremol..wav (1.82 MB)You must be logged in to download this attachment.

    Sound modification controls:
    - rate: oscillator frequency, range 1 - 20Hz
    - depth: modulation intensity, range 0 – 0.5
    - mode: modulation shape, sine/square

    Echo

    The main element of this effect is the delay line. As the name suggests, it is used to delay the input signal by a given amount of time, which can be adjusted. To obtain the effect of many repetitions (echo), the signal from its output is fed to the input, previously multiplied by a factor less than 1 so that the repetitions fade out. In addition to multiplication, a low-pass filter can be used here to suppress high repetition rates and obtain an effect similar to analog echo effects based on magnetic tape.

    echo.wav (1.85 MB)You must be logged in to download this attachment.

    Sound modification controls:
    - blur: blur repetitions (low-pass filter), range 2 – 8kHz
    - time: delay time, range 0.05 – 1s
    - feedback: repetition fading, range 0 – 1
    - mode: selection of echo/delay mode

    Chorus

    It`s just a choir. The main mechanism of this effect is doubling the original sound source, then slightly shifting it in time (and possibly modulating this time) and finally summing it with the original. A delay line is also used here, but its delay time is modulated with a low-frequency oscillator.

    chorus.wav (2.09 MB)You must be logged in to download this attachment.

    Sound modification controls:
    - depth: modulation intensity, range 0 – 1
    - rate: modulation frequency, range 0.05 – 4Hz
    - mix: mix of the original with the effect, range 0 – 1
    - mode: selection of the effect type

    Reverb

    This is an effect that simulates the reverberation in a room, hall, etc. The task of the algorithm is to create a fairly large number of "reflections" of the original signal, circulate them, possibly modulate them, sustain them and then dampen them. A good-sounding reverb algorithm is difficult to develop and is usually computationally demanding due to its complexity. Here I used a certain well-known topology by J. Dattorro from the 1990s, simulating an analog plate reverb.

    reverb.wav (3.05 MB)You must be logged in to download this attachment.

    Sound modification controls:
    - bandwidth: low-pass filter on the input, range 0 – 24kHz
    - decay: reverb length, range 0 – 0.999
    - damping: reflection suppression (DP filter), range 0 – 24kHz
    - mode: effect mode without/with modulation

    Overdrive

    One of the most popular effects in rock and metal music. The main task of the algorithm is to change the shape of the signal in such a way as to "cut" or "flatten" the signal when it exceeds a certain value. In analog effects this is achieved, for example, by using diodes connected in anti-parallel (symmetrical clipping). In digital, however, a non-linear function is usually used, e.g.: y = tanh(kx)/tanh(k) where the argument x is the input signal and y is the output. Using such procedures introduces a number of harmonics into the signal, so it is necessary to remember to reduce the phenomenon of aliasing. Overdrive algorithms use oversampling and decimation for this purpose.

    overdri...wav (2.2 MB)You must be logged in to download this attachment.

    Sound modification controls:
    - gain: signal gain, range 1 – 200
    - tone: tone change (bass/treble), range 0 – 1
    - mix: mix of the original with the effect, range 0 – 1
    - mode: selection of soft/hard clipping type

    Cab sim

    This is a simulation of the sound of a guitar cabinet. It is usually "applied" directly after the overdrive, so that we do not hear the terrible clamor of the distorted signal in the headphones. ;) . It is actually a graphic equalizer without the possibility of adjustment. The algorithm involves convolving the impulse response of a given column with the audio signal. Such a convolution for long impulse responses is computationally expensive, therefore the so-called "fast" convolution using FFT.

    cab si..wav (2.28 MB)You must be logged in to download this attachment.

    Sound modification controls:
    - list with impulses of guitar columns

    What can be added/improved

    I have a list of a few things I plan to add in the future:
    1) guitar tuner
    2) saving/reading effect settings (presets).
    3) designing unique effect panels (currently each panel looks almost the same)
    4) Vocoder effect
    5) footswitch support for changing effects

    What are your suggestions?

    Photos

    Below are a few photos of the screen (sorry for their quality, but it`s hard for me to take a good photo of this LCD screen :/)

    STM32F746G-DISCO touchscreen displaying Chorus effect settings
    Guitar multi-effect screen with chorus effect setting.
    Touch screen showing a list of guitar effects: Tremolo, Chorus, Reverb with editing options.
    Touchscreen displaying audio volume settings and 6% CPU load.

    Sources

    I found most of the theories about audio effects in the following sources:

    1) Udo Zölzer, DAFX: Digital Audio Effects ,Second Edition
    2) Will C. Pirkle, Designing Audio Effect Plugins in C++ ,Second Edition
    3) J. Dattorro, Effect Design, Parts 1 – 3

    and beyond that, all corners of the Internet.

    If I forgot to write about something important - ask in the comments.

    Cool? Ranking DIY
    About Author
    Kwarcu
    Level 13  
    Offline 
    Kwarcu wrote 78 posts with rating 66, helped 5 times. Live in city Kraków. Been with us since 2007 year.
  • ADVERTISEMENT
  • #2 20859473
    gulson
    System Administrator  
    Posts: 29367
    Help: 148
    Rate: 6050
    Thanks for the presentations! Only modernity has crept in.
    Recently, my friends` kids had an electric guitar connected to a tablet and headphones, they were strumming it and the effect was amazing.
    Soon they will probably add artificial intelligence support.
    Contact me with a parcel locker and I will send you a small gift ;)
    I would also like to translate the presentation and post it worldwide: elektroda.com
  • #3 20859489
    Kwarcu
    Level 13  
    Posts: 78
    Help: 5
    Rate: 66
    gulson wrote:
    Soon they will probably add artificial intelligence support.

    Such things are already happening. A recently created project called "Neural Amp Modeler" (as a DAW plug-in) uses machine learning to model the sounds of amplifiers. Apparently it sounds really good.
  • #4 20859903
    austin007
    Level 17  
    Posts: 765
    Help: 6
    Rate: 275
    Nice project and definitely a lot of work. Would it work on weaker platforms like STM32F7F4 or does it have to be on STM32F7F7?
  • ADVERTISEMENT
  • #5 20859962
    Kwarcu
    Level 13  
    Posts: 78
    Help: 5
    Rate: 66
    austin007 wrote:
    Nice project and definitely a lot of work. Would it work on weaker platforms like STM32F7F4 or does it have to be on STM32F7F7?

    Single effects can be easily achieved on Cortex M4 with FPU. It is important that it has hardware support for float numbers and some decent clock speed, above 100MHz. However, a lot depends on the effect algorithm, because for me simple effects (tremolo, chorus, echo) take about 3 - 10% of the CPU time, and reverb and cab sim take about 25%. Cortex-M4 will be slower than M7 because it does not have, for example, branch prediction and I-Cache and D-Cache caches.
  • #6 20860036
    katakrowa
    Level 23  
    Posts: 902
    Help: 9
    Rate: 854
    Great stuff and congratulations on your determination. A nice piece of programming work.
    However, I have a few questions because I got stuck in a very similar topic... and as you can see, it is worth returning because the satisfaction must be considerable.

    1. From the code I see that you have WM8994 as a DAC or do you use the 12-bit built-in uC as an ADC?

    2. Have you considered building it on a slightly faster uC instead of 216MHz, e.g. 550MHz or 480MHz? Maybe instead of 6ms latency you would have 3ms. and this game is worth the candle because such 3ms while playing are almost negligible. What stood in the way of using a stronger system?

    3. Out of pure curiosity, I will ask about how to store graphics files (https://github.com/kwarc93/audio-multieffect/blob/master/app/view/lcd_view/images/ui_img_btn_1_inact_png.c)
    Can`t this be communicated in a less "butchery" way when programming the system? Does this FreeRTOS not provide any facilities for "human" people?

    4. Have you struggled for a long time with configuring your CMSIS DSP libraries? I once tried to tame them on STM32F446 on Nucleo, but I failed. Ultimately, I built the system on ADAU1701 - but the bad taste of failure and the lack of full freedom in signal processing remained :-)
  • #7 20860088
    Kwarcu
    Level 13  
    Posts: 78
    Help: 5
    Rate: 66
    @katakrowa
    Thanks for showing interest ;)
    As for the questions:
    1. Yes, the ADC/DAC is WM8994, the jack sockets on the board are connected to it.
    2. I did it on this platform because I simply had it at hand and I know STM32 well. At the beginning, I didn`t know what and how many effects this CD would have. The latency can be reduced twice (by reducing the audio buffers), but then the CPU consumption will increase and the max. number of effects in the chain, GUI will be more frame-rate, etc. For me the current latency is acceptable.
    3. This method of storing an image is, of course, one of the possible options. You can upload JPEG to a microSD card. You can upload FLASH to an external chip (probably more troublesome). What I`m getting at is that this was the default way to store images in the LVGL graphics library. I will add that I designed the screens in a PC creator dedicated to this library (Squareline Studio), which generates code for the screen.
    4. I didn`t have to fight with CMSIS DSP. I only linked the library (I use it compiled as a *.a file) and defined the necessary macros (ARM_MATH_CM7 type).
  • #8 20860097
    katakrowa
    Level 23  
    Posts: 902
    Help: 9
    Rate: 854
    Kwarcu wrote:
    1. Yes, the ADC/DAC is WM8994, the jack sockets on the board are connected to it.


    I`m blind... it actually has both ADC and DAC.

    Kwarcu wrote:
    4. I didn`t have to fight with CMSIS DSP. I only linked the library (I use it compiled as a *.a file) and defined the necessary macros (ARM_MATH_CM7 type).


    Sounds easy :-) I will have to approach this topic again.

    Thanks for the answers.
  • ADVERTISEMENT
  • #9 20860512
    viayner
    Level 43  
    Posts: 10625
    Help: 1563
    Rate: 2047
    Hello,
    bravo for the idea and execution,
    I used to play around with dsPIC, delay effects, thermolo modulations, simple filters and overdrive can be calculated quite easily and without FFT, even simpler microcontrollers should be able to handle them.
    Regards
  • ADVERTISEMENT
  • #10 20860652
    katakrowa
    Level 23  
    Posts: 902
    Help: 9
    Rate: 854
    viayner wrote:
    I used to play around with dsPIC and delay effects


    Delay, echo and reverbs, however, require a lot of RAM (a lot for microcontrollers). To make a one-second mono delay, a minimum of 88KiB is needed.
  • #11 20861492
    pierkwadrat
    Level 15  
    Posts: 143
    Help: 8
    Rate: 71
    If there were also phase and flanger effects, it would be a dream set :)
  • #12 20861541
    Kwarcu
    Level 13  
    Posts: 78
    Help: 5
    Rate: 66
    pierkwadrat wrote:
    If there were also phase and flanger effects, it would be a dream set

    Nothing stands in the way, but I`m more interested in the vocoder effect, e.g. the one in the video:



    The microphone signal can be fed to the second channel of the line input (or use MEMS microphones on the board).
    Anyway, the code is open source - you can try writing a phaser yourself :)
  • #13 20861681
    pierkwadrat
    Level 15  
    Posts: 143
    Help: 8
    Rate: 71
    Unfortunately, I can`t :(
  • #14 20861994
    viayner
    Level 43  
    Posts: 10625
    Help: 1563
    Rate: 2047
    Hello,
    katakrowa wrote:
    ...Delay, echo and reverbs, however, require a lot of RAM (a lot for microcontrollers). To make a one second mono delay, a minimum of 88 KiB is needed.

    It`s actually not that bad:
    - the effects of mixing the original signal with the modified one can be achieved more easily and many serious companies do it.
    - the signal is sampled with a lower resolution, e.g. 12 bits, and this is enough, even an experienced ear cannot detect it, the same applies to the sampling frequency.
    - it all results from the fact that the modified signal is a small part of the main signal.
    - in typical delays/reverbs you don`t need as much as 1 second of delay, so the amount of memory needed quickly decreases.
    Regards
    PS, phaser support requires FFT and frequency analysis.
    With a vocoder it will be much more difficult, you have to divide the signal into several bands with a filter, change the envelope of each band and mix it.
  • #15 20862199
    Kwarcu
    Level 13  
    Posts: 78
    Help: 5
    Rate: 66
    Interesting optimization tips ;)

    When it comes to RAM, I had no worries about running out of it because there is an external 8MB SDRAM chip on the board in which I keep large buffers for delay lines (as well as an image frame for the LCD). This board is a nice little piece of hardware for a non-Linux embedded device and that`s why I didn`t have to make any compromises. At the beginning, I had the audio set to 16 bit, but if the equipment provides full 24 bits, why not use it (of course, you can`t hear it by ear and the 24 bits are lost in the noise anyway and we effectively have 20 bits).

    viayner wrote:
    PS, phaser support requires FFT and frequency analysis.
    With a vocoder it will be much more difficult, you have to divide the signal into several bands with a filter, change the envelope of each band and mix it.


    From what I remember from the books, phasers can be made using allpass filters, but with a vocoder it will be difficult without FFT. I`m not worried about the lack of computing power because currently the guitar speaker simulation uses fast convolution, where first one FFT is made, then the multiplication of the complex spectra of the signal and the impulse and finally the reverse FFT. This effect takes approximately 25% of the CPU.
  • #16 20864815
    yogi009
    Level 43  
    Posts: 14693
    Help: 848
    Rate: 2650
    More and more from Lem`s novels in these electrode projects :-) Big applause for this presentation. I`m wondering about the quality level, is this an acceptable signal on a big stage?
  • #17 20865148
    Kwarcu
    Level 13  
    Posts: 78
    Help: 5
    Rate: 66
    yogi009 wrote:
    I`m wondering about the quality level, is this an acceptable signal on a big stage?

    I think it`s not at that level yet. I have just entered the field of DSP in audio and my effects are rather basic topologies described in the literature. To achieve a really interesting sound, you would have to spend some time tuning the algorithms (and this is often a process of trial and error). It`s enough for home gaming - it`s fun :D
Reply Cool? Ranking DIY | New topic
Notify about new articles
📢 Listen (AI):
Report a violation of the law

Topic summary

✨ The discussion revolves around the development of a digital multi-effect device for electric guitars using the STM32F746G-DISCO development board. The project focuses on software implementation of effects such as overdrive, cabinet simulation, and reverb. Participants share insights on the feasibility of running the software on different microcontroller platforms, emphasizing the importance of hardware support for floating-point operations and sufficient clock speed. The conversation also touches on the use of the WM8994 DAC/ADC, latency considerations, and memory requirements for effects like delay and reverb. Suggestions for additional effects, such as phaser and vocoder, are made, along with optimization tips for memory usage and signal processing. Overall, the project is seen as a promising prototype, though not yet stage-ready.
Generated by the language model.

FAQ

TL;DR: With 24-bit/48 kHz audio, 128-sample blocks, and about 6 ms latency, this STM32F746G-DISCO guitar multi-effect shows that “simple effects take about 3–10%” CPU while heavier DSP still fits on one board. This FAQ helps embedded-DSP builders understand the hardware, software structure, and effect-chain trade-offs in a real prototype. [#20859439]

Why it matters: This thread turns a hobby prototype into a practical reference for anyone building a low-latency digital guitar processor on STM32.

Platform / option What the thread says Practical effect
Cortex-M4 with FPU, >100 MHz Can handle single effects such as tremolo, chorus, or echo Good for lighter DSP workloads [#20859962]
Cortex-M7 on STM32F746G-DISCO Faster due to branch prediction and I-/D-cache Better for stacked effects, reverb, and cab sim [#20859962]
Smaller audio buffers Can cut latency roughly in half from about 6 ms Raises CPU load and can hurt GUI headroom [#20860088]

Key insight: The project succeeds because it balances DSP ambition with embedded constraints: external SDRAM absorbs big audio buffers, while the M7 keeps six effects and a touchscreen UI responsive enough for home use. [#20862199]

Quick Facts

  • Audio runs at 24-bit / 48 kHz with 128-sample processing blocks, giving about 6 ms input-to-output latency in the current build. [#20859439]
  • The active effect set includes six effects: tremolo, echo/delay, chorus, reverb, overdrive, and cab sim, and the user can place them in the chain in any order. [#20859439]
  • Approximate CPU load is 3–10% for simple effects like tremolo, chorus, and echo, versus about 25% each for reverb and cab sim. [#20859962]
  • Long delay-line storage is offloaded to the board’s external 8 MB SDRAM, which also stores the LCD frame buffer. [#20862199]

How was the digital guitar multi-effect implemented on the STM32F746G-DISCO board, and which hardware features of that board were used for audio and UI?

It was implemented as software-only firmware for the ready-made STM32F746G-DISCO board, not as a custom pedal. The build uses the board’s audio line input and output for the guitar path and the graphic touchscreen display for the user interface. The author chose this platform because it already had the needed hardware and let him focus on DSP algorithms instead of board design. [#20859439]

What audio parameters and processing settings does this STM32 guitar multi-effect use, including sample rate, bit depth, block size, and end-to-end latency?

The project uses 24-bit audio at 48 kHz, processed in 128-sample blocks. That block size gives an end-to-end delay of about 6 ms between input and output. The processing is double-buffered and block-based, which keeps the audio path predictable while effects are chained in software. [#20859439]

How are the six effects in the chain organized in this project, and what controls are available for tremolo, echo, chorus, reverb, overdrive, and cab sim?

The six effects are user-selectable modules that can be inserted into the processing chain in any order from the menu. Tremolo offers rate, depth, and sine/square mode. Echo adds blur, time, feedback, and mode. Chorus uses depth, rate, mix, and mode. Reverb has bandwidth, decay, damping, and modulation mode. Overdrive exposes gain, tone, mix, and soft/hard clipping mode. Cab sim selects from a list of speaker impulses. [#20859439]

What is a cab sim in a digital guitar processor, and why is it usually placed after overdrive or distortion?

“Cab sim” is a speaker-cabinet simulation effect that shapes a guitar signal by convolving it with a cabinet impulse response, recreating the tonal filtering of a real guitar speaker. In this project, it is typically placed directly after overdrive so the player does not hear the harsh, unpleasant raw distorted tone in headphones or speakers. [#20859439]

What is fast convolution with FFT, and why is it useful for speaker cabinet impulse-response simulation on microcontrollers?

“Fast convolution with FFT” is a DSP method that converts a signal and an impulse response into frequency-domain spectra, multiplies them, and transforms the result back, reducing the cost of long convolutions. It matters here because cab sim uses impulse responses of guitar cabinets, and direct time-domain convolution would be too expensive for long responses on a microcontroller. [#20859439]

How does the overdrive algorithm reduce aliasing, and what role do oversampling and decimation play in digital clipping effects?

The overdrive reduces aliasing by oversampling before nonlinear clipping and decimating afterward. The author notes that digital clipping adds many harmonics, so the algorithm must suppress aliasing artifacts. In this build, the clipping can use a nonlinear function such as y = tanh(kx)/tanh(k), with oversampling and decimation handling the spectral cleanup around that nonlinearity. [#20859439]

Why does reducing the audio buffer size lower latency in an STM32-based guitar effect, and what trade-offs does it create for CPU load and GUI performance?

Reducing the audio buffer lowers latency because the system waits for fewer samples before processing and outputting each block. In this project, the author says latency could be cut roughly in half from about 6 ms by shrinking the buffers. The trade-off is higher CPU use, fewer simultaneous effects, and more pressure on GUI responsiveness and frame rate. [#20860088]

STM32 Cortex-M4 with FPU vs Cortex-M7 for guitar DSP: which is better for effects like tremolo, chorus, reverb, and cab sim, and why?

Cortex-M7 is better for stacked guitar DSP, while Cortex-M4 with FPU is sufficient for lighter single effects. The author states that single effects can run on an M4 with hardware floating point and clock speeds above 100 MHz. He also notes that M7 is faster because it adds features such as branch prediction and I-Cache and D-Cache, which help heavier effects like reverb and cab sim. [#20859962]

How much CPU time do simple effects versus heavier effects like reverb and cab sim consume in this project?

Simple effects use about 3–10% of CPU time each, while reverb and cab sim take about 25% each. The lighter group includes tremolo, chorus, and echo. That spread explains why the platform can stack several basic effects comfortably, but heavy ambience or impulse-response processing quickly becomes the performance limit. [#20859962]

Which ADC and DAC path is used on the STM32F746G-DISCO board for this build, and how is the WM8994 codec connected to the jack sockets?

The build uses the board’s WM8994 audio codec for both ADC and DAC. The author explicitly says the jack sockets on the STM32F746G-DISCO board are connected to that codec, so the guitar input and audio output both pass through WM8994 rather than the microcontroller’s internal 12-bit ADC. [#20860088]

How do you integrate CMSIS-DSP into an STM32 audio project, including linking the precompiled library and setting macros such as ARM_MATH_CM7?

The thread describes a simple three-step integration path. 1. Link the CMSIS-DSP library as a precompiled *.a file. 2. Define the required target macro, such as ARM_MATH_CM7. 3. Build the project with those settings enabled. The author says he did not have to fight the library beyond that setup. [#20860088]

What is the MVC architecture in an embedded audio application, and how do event queues under FreeRTOS help separate the model, view, and controller?

MVC in this project separates DSP, UI, and control logic into distinct modules. The model contains the effects processor and algorithms, the view handles the display and user interaction, and the controller mediates between them. The modules communicate through events carried on RTOS queues, so the design stays event-driven and easier to extend with another interface, such as a terminal view. [#20859439]

How are UI graphics stored and generated for LVGL in this project, and what alternatives exist besides embedding image data directly in C files?

The current UI stores image data directly in C files because that was the default approach used with LVGL. The screen layouts were designed in SquareLine Studio, which generated code for the interface. The author also lists two alternatives: load JPEG files from a microSD card or store assets in external flash memory, though he suggests external flash is more troublesome. [#20860088]

What memory requirements should I expect for delay, echo, and reverb on a microcontroller, and how does external SDRAM help with long delay lines?

Expect delay-based effects to consume meaningful RAM, especially as delay time rises. One commenter gives a concrete baseline: a 1-second mono delay needs at least 88 KiB. In this project, the board’s external 8 MB SDRAM removes that bottleneck by storing large delay-line buffers and the LCD frame buffer, so the author did not need major memory compromises. [#20862199]

How could a vocoder, phaser, or flanger be added to this STM32 guitar multi-effect, and which signal-processing methods are most appropriate for each one?

A phaser can be added with all-pass filters, while the author expects a vocoder to be harder and likely FFT-based. He also notes the platform still has DSP headroom because cab sim already performs fast convolution with FFT and uses about 25% CPU. For audio I/O, the microphone signal for a vocoder could enter through the second line-input channel or the board’s MEMS microphones. [#20862199]
Generated by the language model.
ADVERTISEMENT