🪴 TJ's Notes 1.0

Untitled 1

6 min read

To implement the strumming pattern shown in the image for the guitar chords, you can modify the apply_strumming function to replicate the pattern specified (downstrokes and upstrokes) for each chord.

Steps to Implement the Strumming Pattern:

  1. Identify the Strumming Pattern: The pattern from the image has a combination of down (↓) and up (↑) strokes with specific timings.
  2. Apply the Pattern to Each Chord: Modify the existing code to use this specific strumming pattern.

Here’s a breakdown of the strumming pattern:

  • Main Pattern:
    • Downstroke on beats 1, 2 (with the first one being accented), 3, and an upstroke on the & after 3, followed by a downstroke on 4 and an upstroke on the last &.
    This can be represented in a more structured form:
    • 1 (D)
    • 2 (D)
    • 3 (D)
    • & (U)
    • 4 (D)
    • & (U)

Updated MATLAB Code

Here’s how you could implement the specified strumming pattern:

% Sampling frequency
Fs = 44100;
 
% Duration for each chord
chord_duration = 1;  % 1 second per chord
strum_time = 0.2;    % Duration for each strum event (downstroke/upstroke)
 
% Frequencies of notes in each chord
Em = [82.41, 123.47, 164.81, 196.00, 246.94, 329.63];  % Em chord
A = [110.00, 164.81, 220.00, 277.18, 329.63, 440.00];  % A chord
G = [98.00, 123.47, 146.83, 196.00, 246.94, 392.00];   % G chord
C = [130.81, 164.81, 196.00, 261.63, 329.63, 392.00];  % C chord
 
% Generate the chords for the first 5 seconds
chord_signals = [
    generate_chord(Em, Fs, chord_duration), ...
    generate_chord(A, Fs, chord_duration), ...
    generate_chord(G, Fs, chord_duration), ...
    generate_chord(C, Fs, chord_duration), ...
    generate_chord(Em, Fs, chord_duration)  % Repeat Em for the interlude
];
 
% Define the strumming pattern (as per the image)
strumming_pattern = [1, 1, 1, 0.5, 1, 0.5];  % 1 = downstroke, 0.5 = upstroke
strum_counts = [2, 2];  % How many chords per section
 
% Create a function to apply the strumming pattern
function strummed_signal = apply_custom_strumming(chords, pattern, Fs, strum_time)
    strummed_signal = zeros(1, length(chords));
    for i = 1:length(chords)
        % For each chord, apply the strumming pattern
        for j = 1:length(pattern)
            if pattern(j) == 1  % Downstroke
                % Use the full chord duration for downstroke
                strummed_signal((i-1)*length(chords)+1:i*length(chords)) = ...
                    strummed_signal((i-1)*length(chords)+1:i*length(chords)) + chords{i};
            elseif pattern(j) == 0.5  % Upstroke
                % Create a softer version of the chord or silence
                strummed_signal((i-1)*length(chords)+1:i*length(chords)) = ...
                    strummed_signal((i-1)*length(chords)+1:i*length(chords)) + 0.5 * chords{i};
            end
            pause(strum_time);  % Pause to simulate strum timing
        end
    end
end
 
% Generate the strummed chord sequence
strummed_signal = apply_custom_strumming(chord_signals, strumming_pattern, Fs, strum_time);
 
% Play the final strummed signal
sound(strummed_signal, Fs);
disp('Playing Strummed Signal with Custom Pattern');
pause(1);  % Pause to allow playback

Explanation:

  1. Strumming Pattern Definition: The pattern is defined as an array where 1 represents a downstroke and 0.5 represents an upstroke. This aligns with the visual representation in your image.
  2. Custom Strumming Function: The apply_custom_strumming function loops through each chord, applying the strumming pattern by modifying the signal amplitude based on whether it’s a downstroke or upstroke.
  3. Playback: The final strummed signal is played back with the specified strumming pattern.

Further Customization:

  • Adjust the amplitude scaling for the upstrokes to make them softer or change the duration of pauses between strums for timing adjustments.

This implementation should closely mimic the strumming pattern depicted in the image. Let me know if you need any further adjustments or clarifications!

Here’s a timestamp-wise instruction set based on the strumming pattern and chord progressions from the image. You can use this structure to implement in MATLAB, particularly for generating audio or guiding a performance.

Implementation Instructions for MATLAB

Setup:

  • Chords to use:

    • Em (E minor)
    • A
    • G
    • C

  • Tempo: 116 BPM (Beats Per Minute)

  • Duration per beat: 60 seconds / 116 beats = ~0.517 seconds per beat

Strumming Instructions:

Here’s a breakdown of the strumming pattern, focusing on each strum with its respective timestamp:

[Intro/Riff] (4 Times)

  1. 0:00 - 0:00.517

    • Strum Em (Down)

  2. 0:00.517 - 0:01.034

    • Strum Em (Up)

  3. 0:01.034 - 0:01.551

    • Strum Em (Muted)

  4. 0:01.551 - 0:02.068

    • Strum Em (Down)

  5. 0:02.068 - 0:02.585

    • Strum Em (Up)

  6. 0:02.585 - 0:03.102

    • Strum Em (Muted)

  7. 0:03.102 - 0:03.619

    • Strum Em (Down)

  8. 0:03.619 - 0:04.136

    • Strum Em (Up)

  9. 0:04.136 - 0:04.653

    • Strum Em (Muted)

  10. 0:04.653 - 0:05.17

    • Strum A (Down)

  11. 0:05.17 - 0:05.687

    • Strum A (Up)

  12. 0:05.687 - 0:06.204

    • Strum A (Muted)

  13. 0:06.204 - 0:06.721

    • Strum A (Down)

  14. 0:06.721 - 0:07.238

    • Strum A (Up)

  15. 0:07.238 - 0:07.755

    • Strum A (Muted)

  16. 0:07.755 - 0:08.272

    • Strum A (Down)

  17. 0:08.272 - 0:08.789

    • Strum A (Up)

  18. 0:08.789 - 0:09.306

    • Strum A (Muted)

  19. 0:09.306 - 0:09.823

    • Strum G (Down)

  20. 0:09.823 - 0:10.34

    • Strum G (Up)

  21. 0:10.34 - 0:10.857

    • Strum G (Muted)

  22. 0:10.857 - 0:11.374

    • Strum G (Down)

  23. 0:11.374 - 0:11.891

    • Strum G (Up)

  24. 0:11.891 - 0:12.408

    • Strum G (Muted)

  25. 0:12.408 - 0:12.925

    • Strum G (Down)

  26. 0:12.925 - 0:13.442

    • Strum G (Up)

  27. 0:13.442 - 0:13.959

    • Strum G (Muted)

  28. 0:13.959 - 0:14.476

    • Strum C (Down)

  29. 0:14.476 - 0:14.993

    • Strum C (Up)

  30. 0:14.993 - 0:15.51

    • Strum C (Muted)

  31. 0:15.51 - 0:16.027

    • Strum C (Down)

  32. 0:16.027 - 0:16.544

    • Strum C (Up)

  33. 0:16.544 - 0:17.061

    • Strum C (Muted)

  34. 0:17.061 - 0:17.578

    • Strum C (Down)

  35. 0:17.578 - 0:18.095

    • Strum C (Up)

  36. 0:18.095 - 0:18.612

    • Strum C (Muted)

  37. Repeat the above 4 times.

[Interlude] (2 Times)

  • Follow the same pattern for Em A G C but repeat only 2 times instead of 4.

Example MATLAB Code Structure

You can use this structure to implement the timing and chords in MATLAB. Here’s a basic outline to get you started:

% Setup
fs = 44100; % Sampling frequency
duration = 0.517; % Duration of each beat
t = 0:1/fs:duration; % Time vector
 
% Define the chords (sample sine waves)
Em = sin(2 * pi * 164.81 * t); % E note (E minor)
A = sin(2 * pi * 220.00 * t);  % A note
G = sin(2 * pi * 196.00 * t);  % G note
C = sin(2 * pi * 261.63 * t);  % C note
 
% Play each chord with timestamps
for i = 1:4
    sound(Em, fs); pause(duration); % Em
    sound(A, fs); pause(duration);   % A
    sound(G, fs); pause(duration);   % G
    sound(C, fs); pause(duration);   % C
end
 
% For interlude
for i = 1:2
    sound(Em, fs); pause(duration); % Em
    sound(A, fs); pause(duration);   % A
    sound(G, fs); pause(duration);   % G
    sound(C, fs); pause(duration);   % C
end

Notes:

  • You can modify the sine wave frequencies to create more realistic guitar sounds if you want.
  • Use audio libraries or samples for a more realistic sound.
  • Adjust the pause duration and ensure the timing aligns with the beat.

Feel free to ask if you need more details or help with specific implementations!

Graph View

Backlinks

  • No backlinks found