rkcf
/
esp32-sequencer
Archived
1
0
Fork 0
Code Issues 12 Pull Requests Packages Projects 2 Releases Wiki Activity

Compare commits

base: rkcf:000afa206226c58a4642c362053815072096973c
Branches Tags
rkcf:main
..
compare: rkcf:9e0ece753d8cf30b7a62a4d0838d5601aee57d55
Branches Tags
rkcf:main

3 Commits
000afa2062 ... 9e0ece753d

Author SHA1 Message Date
rkcf 9e0ece753d refactor led/clock/gate timers into single gate timer 2023-01-28 11:47:10 -06:00
rkcf f52697412c minor refactor and code cleanup 2023-01-28 11:26:00 -06:00
rkcf 0ba47039f8 refactor change if/else to switch case 2023-01-28 11:17:27 -06:00
1 changed files with 40 additions and 108 deletions
Show Stats Expand all files Collapse all files

148
main/esp32-sequencer.c
View File

@ -3,55 +3,49 @@
#include "driver/gpio.h" #include "driver/gpio.h"
#include "driver/gptimer.h" #include "driver/gptimer.h"
#include "driver/ledc.h"
#include "esp_attr.h" #include "esp_attr.h"
#include "esp_err.h" #include "esp_err.h"
#include "esp_random.h"
#include "esp_log.h" #include "esp_log.h"
#include "esp_random.h"
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h" #include "freertos/queue.h"
#include "freertos/task.h"
#include "driver/ledc.h"
#include "hal/gpio_types.h" #include "hal/gpio_types.h"
#include "hal/ledc_types.h" #include "hal/ledc_types.h"
#include "hal/timer_types.h" #include "hal/timer_types.h"
#include "soc/clk_tree_defs.h" #include "soc/clk_tree_defs.h"
#define SEQ_MAX_LEN 8
/* Inputs */ /* Inputs */
// Clock In // Clock In
// Reset In
/* Controls */ /* Controls */
#define GPIO_MUTATE_BTN (9) // Mutate Button In #define GPIO_MUTATE_BTN (9) // Mutate Button In
#define GPIO_TAP_TEMPO_BTN (10) // Tap Tempo Button In #define GPIO_TAP_TEMPO_BTN (10) // Tap Tempo Button In
gptimer_handle_t tap_tempo_timer = NULL;
static QueueHandle_t control_event_queue = NULL; static QueueHandle_t control_event_queue = NULL;
/* Outputs */ /* Outputs */
#define GPIO_CLK_OUT (7) // Clock Out #define GPIO_CLK_OUT (7) // Clock Out
#define GPIO_GATE_OUT (8) // Gate CV Out #define GPIO_GATE_OUT (8) // Gate CV Out
gptimer_handle_t clk_cv_timer = NULL;
gptimer_handle_t gate_cv_timer = NULL;
/* LED GPIO Pins */ /* LED GPIO Pins */
#define LEDC_CLK_OUT (5) #define LEDC_CLK_OUT (5)
#define LEDC_GATE_OUT (6) #define LEDC_GATE_OUT (6)
gptimer_handle_t clk_blink_timer = NULL; /* Timers */
gptimer_handle_t gate_blink_timer = NULL; gptimer_handle_t tap_tempo_timer = NULL;
gptimer_handle_t gate_timer = NULL;
uint8_t sequence[SEQ_MAX_LEN] = {0};
uint8_t seq_len = SEQ_MAX_LEN;
static const uint32_t DEFAULT_BPM = 120; static const uint32_t DEFAULT_BPM = 120;
#define SEQ_MAX_LEN 8
static uint8_t sequence[SEQ_MAX_LEN] = {0};
static uint8_t seq_len = SEQ_MAX_LEN;
static const char *TAG = "sequencer"; static const char *TAG = "sequencer";
uint32_t bpm_to_ms(uint32_t bpm) { uint32_t bpm_to_ms(uint32_t bpm) {
return 60000 / bpm; return 60000 / bpm;
} }
@ -90,6 +84,7 @@ static void control_event_handler(void* arg) {
switch (gpio_num) { switch (gpio_num) {
case GPIO_MUTATE_BTN: case GPIO_MUTATE_BTN:
mutate_seq(sequence); mutate_seq(sequence);
break;
} }
} }
} }
@ -122,14 +117,14 @@ static void controls_init(void) {
ESP_ERROR_CHECK(gptimer_enable(tap_tempo_timer)); ESP_ERROR_CHECK(gptimer_enable(tap_tempo_timer));
} }
static void clk_cv_off_alarm_cb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data) { static void gate_off_alarm_cb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data) {
gptimer_stop(clk_cv_timer); gptimer_stop(gate_timer);
gpio_set_level(GPIO_CLK_OUT, 0);
}
static void gate_cv_off_alarm_cb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data) {
gptimer_stop(gate_cv_timer);
gpio_set_level(GPIO_GATE_OUT, 0); gpio_set_level(GPIO_GATE_OUT, 0);
gpio_set_level(GPIO_CLK_OUT, 0);
ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1, 0));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1));
ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, 0));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0));
} }
static void gpio_init(void) { static void gpio_init(void) {
@ -142,47 +137,26 @@ static void gpio_init(void) {
gpio_reset_pin(GPIO_GATE_OUT); gpio_reset_pin(GPIO_GATE_OUT);
gpio_set_direction(GPIO_GATE_OUT, GPIO_MODE_OUTPUT); gpio_set_direction(GPIO_GATE_OUT, GPIO_MODE_OUTPUT);
// Setup CV output timer // Setup gate timer
gptimer_config_t cv_out_timer_config = { gptimer_config_t cv_out_timer_config = {
.clk_src = GPTIMER_CLK_SRC_DEFAULT, .clk_src = GPTIMER_CLK_SRC_DEFAULT,
.direction = GPTIMER_COUNT_UP, .direction = GPTIMER_COUNT_UP,
.resolution_hz = 1 * 1000 * 1000 // 1MHz; 1 tick = 1 µs .resolution_hz = 1 * 1000 * 1000 // 1MHz; 1 tick = 1 µs
}; };
ESP_ERROR_CHECK(gptimer_new_timer(&cv_out_timer_config, &clk_cv_timer)); ESP_ERROR_CHECK(gptimer_new_timer(&cv_out_timer_config, &gate_timer));
ESP_ERROR_CHECK(gptimer_new_timer(&cv_out_timer_config, &gate_cv_timer));
// Configure timer alarm // Configure gate timer alarm
gptimer_alarm_config_t cv_off_alarm_config = { gptimer_alarm_config_t cv_off_alarm_config = {
.alarm_count = 10 * 1000, // 10ms @ 1MHz .alarm_count = 20 * 1000, // 20ms @ 1MHz
.reload_count = 0, .reload_count = 0,
.flags.auto_reload_on_alarm = true .flags.auto_reload_on_alarm = true
}; };
ESP_ERROR_CHECK(gptimer_set_alarm_action(clk_cv_timer, &cv_off_alarm_config)); ESP_ERROR_CHECK(gptimer_set_alarm_action(gate_timer, &cv_off_alarm_config));
ESP_ERROR_CHECK(gptimer_set_alarm_action(gate_cv_timer, &cv_off_alarm_config));
//register clk callback //register gate timer callback
gptimer_event_callbacks_t clk_cbs = {.on_alarm = clk_cv_off_alarm_cb}; gptimer_event_callbacks_t clk_cbs = {.on_alarm = gate_off_alarm_cb};
ESP_ERROR_CHECK( ESP_ERROR_CHECK(gptimer_register_event_callbacks(gate_timer, &clk_cbs, NULL));
gptimer_register_event_callbacks(clk_cv_timer, &clk_cbs, NULL)); ESP_ERROR_CHECK(gptimer_enable(gate_timer));
ESP_ERROR_CHECK(gptimer_enable(clk_cv_timer));
// register gate callback
gptimer_event_callbacks_t gate_cbs = {.on_alarm = gate_cv_off_alarm_cb};
ESP_ERROR_CHECK(
gptimer_register_event_callbacks(gate_cv_timer, &gate_cbs, NULL));
ESP_ERROR_CHECK(gptimer_enable(gate_cv_timer));
}
static void gate_led_off_alarm_cb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data) {
gptimer_stop(gate_blink_timer);
ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1, 0));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1));
}
static void clk_led_off_alarm_cb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_data) {
gptimer_stop(clk_blink_timer);
ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, 0));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0));
} }
static void ledc_init(void) { static void ledc_init(void) {
@ -219,55 +193,17 @@ static void ledc_init(void) {
.hpoint = 0 .hpoint = 0
}; };
ESP_ERROR_CHECK(ledc_channel_config(&ledc_gate_channel)); ESP_ERROR_CHECK(ledc_channel_config(&ledc_gate_channel));
// Setup LED blink timer
gptimer_config_t led_blink_timer_config = {
.clk_src = GPTIMER_CLK_SRC_DEFAULT,
.direction = GPTIMER_COUNT_UP,
.resolution_hz = 1 * 1000 * 1000 // 1MHz; 1 tick = 1 µs
};
ESP_ERROR_CHECK(gptimer_new_timer(&led_blink_timer_config, &clk_blink_timer));
ESP_ERROR_CHECK(gptimer_new_timer(&led_blink_timer_config, &gate_blink_timer));
// Configure timer alarm
gptimer_alarm_config_t led_off_alarm_config = {
.alarm_count = 50 * 1000, // 50ms @ 1MHz
.reload_count = 0,
.flags.auto_reload_on_alarm = true
};
ESP_ERROR_CHECK(gptimer_set_alarm_action(clk_blink_timer, &led_off_alarm_config));
ESP_ERROR_CHECK(gptimer_set_alarm_action(gate_blink_timer, &led_off_alarm_config));
//register clk callback
gptimer_event_callbacks_t clk_cbs = {.on_alarm = clk_led_off_alarm_cb};
ESP_ERROR_CHECK(
gptimer_register_event_callbacks(clk_blink_timer, &clk_cbs, NULL));
ESP_ERROR_CHECK(gptimer_enable(clk_blink_timer));
// register gate callback
gptimer_event_callbacks_t gate_cbs = {.on_alarm = gate_led_off_alarm_cb};
ESP_ERROR_CHECK(
gptimer_register_event_callbacks(gate_blink_timer, &gate_cbs, NULL));
ESP_ERROR_CHECK(gptimer_enable(gate_blink_timer));
} }
static void blink_led(ledc_channel_t channel) { static void pulse_cv(bool triggered) {
ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, channel, 4095)); ESP_ERROR_CHECK(gptimer_start(gate_timer));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, channel)); ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, 4095));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0));
if (channel == LEDC_CHANNEL_0) { gpio_set_level(GPIO_CLK_OUT, 1);
ESP_ERROR_CHECK(gptimer_start(clk_blink_timer)); if (triggered) {
} else if (channel == LEDC_CHANNEL_1) { gpio_set_level(GPIO_GATE_OUT, 1);
ESP_ERROR_CHECK(gptimer_start(gate_blink_timer)); ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1, 4095));
} ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1));
}
static void pulse_cv(uint8_t gpio_num) {
gpio_set_level(gpio_num, 1);
if (gpio_num == GPIO_CLK_OUT) {
ESP_ERROR_CHECK(gptimer_start(clk_cv_timer));
} else if (gpio_num == GPIO_GATE_OUT) {
ESP_ERROR_CHECK(gptimer_start(gate_cv_timer));
} }
} }
@ -285,18 +221,14 @@ void app_main(void) {
/* Initialize sequence */ /* Initialize sequence */
randomize_seq(sequence); randomize_seq(sequence);
/* Main Loop */ /* Main Loop */
while (1) { while (1) {
for (uint8_t step = 0; step < seq_len; step++) { for (uint8_t step = 0; step < seq_len; step++) {
blink_led(LEDC_CHANNEL_0); // blink clock led
pulse_cv(GPIO_CLK_OUT);
// if step has been set for sequence // if step has been set for sequence
if (sequence[step] == 1) { if (sequence[step] == 1) {
pulse_cv(GPIO_GATE_OUT); pulse_cv(true);
blink_led(LEDC_CHANNEL_1); // blink gate triggered led } else {
pulse_cv(false);
} }
printf("%i", sequence[step]); printf("%i", sequence[step]);
vTaskDelay(bpm_to_ms(DEFAULT_BPM)/ portTICK_PERIOD_MS); vTaskDelay(bpm_to_ms(DEFAULT_BPM)/ portTICK_PERIOD_MS);