Keyboard Synthesizer with Drums and GUI

// dont let the total mixed value go over 16 bits
// just set it to the max if it goes over
if (samp_sum < -32768) {
    samp_sum = -32768;
} 
else if (samp_sum > 32767) {
    samp_sum = 32767;
}
                    
// Map from [-32768, 32767] to [0, 4096] (signed 16 bit to unsigned 12 bit)
int32_t shifted_mix = (int32_t)mix + 32768;         // shift all of the values to be positive
int16_t scaled_mix = shifted_mix * 4096;            // mulitply by our PWM range
uint16_t pwm_val = (uint16_t)(scaled_mix / 65536);  // scale it back down to the [0, 4096]
// UNSIGNED for pwm!!

pwm_set_gpio_level(pwm_output_pin, pwm_val);
                

// Set up the touch pads for interupts
for (int i = 0; i < num_pads; i++) {
    gpio_init(Drum_Pads[i]);
    gpio_set_dir(Drum_Pads[i], GPIO_IN);
    
    // Use with_callback for all touch sensors
    gpio_set_irq_enabled_with_callback(Drum_Pads[i],        // cycle through all the pads
                                        GPIO_IRQ_EDGE_RISE,   // set at rising edge interupt
                                        true,                 // we want the interupt to be working
                                        &gpio_isr);           // use the gpio_isr function as a callback
}

// Set up the pushbuttons for interupts
for (int i = 0; i < num_buttons; i++) {
    // Configure pin as input with pull-up resistor
    gpio_init(pusshbuttons[i]);
    gpio_set_dir(pusshbuttons[i], GPIO_IN);
    gpio_pull_up(pusshbuttons[i]);              // set a pullup resistor
    
    // Enable interrupt for falling edge (button press) and set callback
    // callback not needed as they should default to the previously set callback
    // included in case someone wishes to use only buttons in there project
    gpio_set_irq_enabled_with_callback(pusshbuttons[i], 
                                       GPIO_IRQ_EDGE_FALL, 
                                       true, 
                                       &gpio_isr);
}
                

void bit_set(volatile uint32_t *track_bitmap, uint8_t tracknumber) {
    // OR the track bit position with 1 to set it
    *track_bitmap |= 1 << tracknumber;
}

void bit_clr(volatile uint32_t *track_bitmap, uint8_t tracknumber) {
    // AND the track bit position with 0 to clear it
    *track_bitmap &= ~(1 << tracknumber);
}

uint8_t testbit(uint32_t track_bitmap, uint8_t tracknumber) {
    // shift everything right by our track nunber and chekc its value
    // AND with the mask 
    return (track_bitmap >> tracknumber) & 0x01;
}
                

void gpio_isr(uint gpio, uint32_t events) {
    . 
    . 

    if (is_touch_sensor) { // if the interupt was triggered by a touch sensor (drum pad)
        . 
        . 
        .
        bit_set(tracks_playing, touched_pad);                              // set the track to play
        samples_left_to_play[touched_pad] = total_samples[touched_pad];    // Initiall, our samples left to play is ALL of the samples  
        . 
        return
    }
    . 
    . 
}
                

int32_t samp_sum = 0;   // 32 bit integer for the raw sum of the samples
                    
// figure out which tracks are playing 
for (int i = 0; i < TRACK_NR; i++) { // for every track we have

    if (testbit(tracks_playing, i) == 1) { // if it is currently playing

        // get the index of the sample we need to play
        uint32_t current_sample_index = total_samples[i] - samples_left_to_play[i];

        // if we still have samples left to play
        // and if the index is valid
        if (current_sample_index < total_samples[i] && tracks[i] != NULL) {  
            samp_sum += tracks[i][current_sample_index];
            samples_left_to_play[i]--;  // Decrement number of samples left to play
            
            if (samples_left_to_play[i] <= 0) {
                bit_clr(tracks_playing, i);  // Finished playing this track
            }
        } else {
            // we have completed playing that sample so just exit now
            bit_clr(tracks_playing, i); // clear the bit so that we wont keep trying to play this track
        
        }
    }
}
                

// Add an event to the loop
void add_loop_event(uint8_t track) {
    if (loop_event_count < MAX_LOOP_EVENTS) {
        uint64_t current_time = time_us_64();
        uint64_t triggered_time = current_time - loop_start_time;
        
        loop_events[loop_event_count].track = track;
        loop_events[loop_event_count].timestamp = triggered_time;
        loop_event_count++;
    }
}
                

void check_loop_events() {

    // if we are in the playback loop mode
    // and if we have something in the loop
    if (play_mode && loop_duration > 0) {

        // loop through all of the loop events
        for (int i = 0; i < loop_event_count; i++) {

            // check if each event should have played yet,
            // have a window just to make sure we dont miss any of the beats, (even if they are slightly incorrectly timed)
            if (loop_events[i].timestamp <= loop_timestamp && 
                loop_events[i].timestamp > loop_timestamp - 5000) { // 5ms window

                uint8_t track = loop_events[i].track; // get the track that we should be playing

                if (track < TRACK_NR) { // if its an actual track
                    bit_set(tracks_playing, track);
                    samples_left_to_play[track] = total_samples[track];
                }
            }
        }
        
        // if we have completed the loop then set the timestamp back to zero so we start again
        if (loop_timestamp >= loop_duration) {

            loop_timestamp = 0; 
            
        }
    }
}
                    

void gpio_isr(uint gpio, uint32_t events) {
    . 
    . 
    . 
    if (is_touch_sensor) {
        . 
        . 
        .
        if (sound_select_mode) {
            if (current_button_to_configure == touched_pad) {
                // Button already selected, cycle through available sounds, make sure to wrap around
                currently_selected_sound = (currently_selected_sound + 1) % total_num_tracks;

                // switch the track that is currently assigned to the pad
                button_sound_mapping[touched_pad] = currently_selected_sound;
                
                // update how long the samples are so that the sound playing works
                total_samples[touched_pad] = available_sounds_sizes[currently_selected_sound];

                // change the current list of tracks that we play
                tracks[touched_pad] = available_sounds[currently_selected_sound];
                
                // Play the new sound so we can hear what we are selecting 
                bit_set(tracks_playing, touched_pad);
                samples_left_to_play[touched_pad] = total_samples[touched_pad];
                
            } else {
                // just touched a new pad
                // set it as the drum pad we are currently configuring
                current_button_to_configure = touched_pad;

                // update the array that holds the sound currently corresponding to each touch pad
                currently_selected_sound = button_sound_mapping[touched_pad];   
                
                // Play the current sound before we make any changes
                bit_set(tracks_playing, touched_pad);
                samples_left_to_play[touched_pad] = total_samples[touched_pad];
            }
            return;
        }
        . 
        . 
    }
    . 
    .
}