Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • 89-apps-should-be-able-to-specify-if-they-want-wifi-to-be-disabled-when-entering-them
  • 9Rmain
  • allow-reloading-sunmenu
  • always-have-a-wifi-instance
  • anon/gpndemo
  • anon/update-sim
  • anon/webflasher
  • app_text_viewer
  • audio_input
  • audio_io
  • blm_dev_chan
  • ch3/bl00mbox_docs
  • ci-1690580595
  • dev_p4
  • dev_p4-iggy
  • dev_p4-iggy-rebased
  • dx/dldldld
  • dx/fb-save-restore
  • dx/hint-hint
  • dx/jacksense-headset-mic-only
  • events
  • fil3s-limit-filesize
  • fil3s-media
  • fpletz/flake
  • gr33nhouse-improvements
  • history-rewrite
  • icon-flower
  • iggy/stemming
  • iggy/stemming_merge
  • led_fix_fix
  • main
  • main+schneider
  • media_has_video_has_audio
  • micropython_api
  • mixer2
  • moon2_demo_temp
  • moon2_migrate_apps
  • more-accurate-battery
  • pippin/ctx_sprite_sheet_support
  • pippin/display-python-errors-on-display
  • pippin/make_empty_drawlists_skip_render_and_blit
  • pippin/more-accurate-battery
  • pippin/tcp_redirect_hack
  • pippin/tune_ctx_config_update_from_upstream
  • pippin/uhm_flash_access_bust
  • pressable_bugfix
  • py_only_update_fps_overlay_when_changing
  • q3k/doom-poc
  • q3k/render-to-texture
  • rahix/flow3rseeds
  • raw_captouch_new
  • raw_captouch_old
  • release/1.0.0
  • release/1.1.0
  • release/1.1.1
  • release/1.2.0
  • release/1.3.0
  • release/1.4.0
  • restore_blit
  • return_of_melodic_demo
  • rev4_micropython
  • schneider/application-remove-name
  • schneider/bhi581
  • schneider/factory_test
  • schneider/recovery
  • scope_hack
  • sdkconfig-spiram-tinyusb
  • sec/auto-nick
  • sec/blinky
  • sector_size_512
  • shoegaze-fps
  • smaller_gradient_lut
  • store_delta_ms_and_ins_as_class_members
  • task_cleanup
  • uctx-wip
  • w1f1-in-sim
  • widgets_draw
  • wifi-json-error-handling
  • wip-docs
  • wip-tinyusb
  • v1.0.0
  • v1.0.0+rc1
  • v1.0.0+rc2
  • v1.0.0+rc3
  • v1.0.0+rc4
  • v1.0.0+rc5
  • v1.0.0+rc6
  • v1.1.0
  • v1.1.0+rc1
  • v1.1.1
  • v1.2.0
  • v1.2.0+rc1
  • v1.3.0
  • v1.4.0
94 results

Target

Select target project
  • flow3r/flow3r-firmware
  • Vespasian/flow3r-firmware
  • alxndr42/flow3r-firmware
  • pl/flow3r-firmware
  • Kari/flow3r-firmware
  • raimue/flow3r-firmware
  • grandchild/flow3r-firmware
  • mu5tach3/flow3r-firmware
  • Nervengift/flow3r-firmware
  • arachnist/flow3r-firmware
  • TheNewCivilian/flow3r-firmware
  • alibi/flow3r-firmware
  • manuel_v/flow3r-firmware
  • xeniter/flow3r-firmware
  • maxbachmann/flow3r-firmware
  • yGifoom/flow3r-firmware
  • istobic/flow3r-firmware
  • EiNSTeiN_/flow3r-firmware
  • gnudalf/flow3r-firmware
  • 999eagle/flow3r-firmware
  • toerb/flow3r-firmware
  • pandark/flow3r-firmware
  • teal/flow3r-firmware
  • x42/flow3r-firmware
  • alufers/flow3r-firmware
  • dos/flow3r-firmware
  • yrlf/flow3r-firmware
  • LuKaRo/flow3r-firmware
  • ThomasElRubio/flow3r-firmware
  • ai/flow3r-firmware
  • T_X/flow3r-firmware
  • highTower/flow3r-firmware
  • beanieboi/flow3r-firmware
  • Woazboat/flow3r-firmware
  • gooniesbro/flow3r-firmware
  • marvino/flow3r-firmware
  • kressnerd/flow3r-firmware
  • quazgar/flow3r-firmware
  • aoid/flow3r-firmware
  • jkj/flow3r-firmware
  • naomi/flow3r-firmware
41 results
Select Git revision
  • 9Rmain
  • anon/appstore
  • anon/gpndemo
  • anon/update-sim
  • anon/webflasher
  • audio_input
  • audio_io
  • bl00mbox
  • bl00mbox_old
  • blm_docs
  • ch3/bl00mbox_docs
  • ci-1690580595
  • compressor
  • dev_p4
  • dev_p4-iggy
  • dev_p4-iggy-rebased
  • events
  • fm_fix
  • fm_fix2
  • history-rewrite
  • icon-flower
  • iggy/stemming
  • iggy/stemming_merge
  • main
  • main+schneider
  • micropython_api
  • moon2_applications
  • moon2_demo_temp
  • moon2_gay_drums
  • pippin/display-python-errors-on-display
  • pippin/make_empty_drawlists_skip_render_and_blit
  • pippin/media_framework
  • pippin/uhm_flash_access_bust
  • pressable_bugfix
  • q3k/doom-poc
  • raw_captouch_new
  • raw_captouch_old
  • release/1.0.0
  • rev4_micropython
  • schneider/application-remove-name
  • schneider/bhi581
  • schneider/factory_test
  • schneider/recovery
  • scope_hack
  • sdkconfig-spiram-tinyusb
  • sec/blinky
  • uctx-wip
  • wip-docs
  • wip-tinyusb
  • v1.0.0
  • v1.0.0+rc1
  • v1.0.0+rc2
  • v1.0.0+rc3
  • v1.0.0+rc4
  • v1.0.0+rc5
  • v1.0.0+rc6
56 results
Show changes
Showing
with 1 addition and 3245 deletions
#include "badge23/audio.h"
#include "badge23/synth.h"
#include "badge23/lock.h"
#include "st3m_scope.h"
#include "driver/i2s.h"
#include "driver/i2c.h"
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/queue.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#define TIMEOUT_MS 1000
#define I2C_MASTER_NUM 0 /*!< I2C master i2c port number, the number of i2c peripheral interfaces available will depend on the chip */
static void audio_player_task(void* arg);
#define DMA_BUFFER_SIZE 64
#define DMA_BUFFER_COUNT 2
#define I2S_PORT 0
// used for exp(vol_dB * NAT_LOG_DB)
#define NAT_LOG_DB 0.1151292546497023
// placeholder for "fake mute" -inf dB (we know floats can do that but we have trust issues when using NAN)
#define SILLY_LOW_VOLUME_DB (-10000.)
static bool headphones_connected = 0;
static bool headset_connected = 0;
static bool line_in_connected = 0;
static bool headphones_detection_override = 0;
static int32_t software_volume = 0;
// maybe struct these someday but eh it works
static float headphones_volume_dB = 0;
static bool headphones_mute = 0;
const static float headphones_maximum_volume_system_dB = 3;
static float headphones_maximum_volume_user_dB = headphones_maximum_volume_system_dB;
static float headphones_minimum_volume_user_dB = headphones_maximum_volume_system_dB - 70;
static float speaker_volume_dB = 0;
static bool speaker_mute = 0;
const static float speaker_maximum_volume_system_dB = 14;
static float speaker_maximum_volume_user_dB = speaker_maximum_volume_system_dB;
static float speaker_minimum_volume_user_dB = speaker_maximum_volume_system_dB - 60;
uint8_t audio_headset_is_connected(){ return headset_connected; }
uint8_t audio_headphones_are_connected(){ return headphones_connected || headphones_detection_override; }
float audio_headphones_get_volume_dB(){ return headphones_volume_dB; }
float audio_speaker_get_volume_dB(){ return speaker_volume_dB; }
float audio_headphones_get_minimum_volume_dB(){ return headphones_minimum_volume_user_dB; }
float audio_speaker_get_minimum_volume_dB(){ return speaker_minimum_volume_user_dB; }
float audio_headphones_get_maximum_volume_dB(){ return headphones_maximum_volume_user_dB; }
float audio_speaker_get_maximum_volume_dB(){ return speaker_maximum_volume_user_dB; }
uint8_t audio_headphones_get_mute(){ return headphones_mute ? 1 : 0; }
uint8_t audio_speaker_get_mute(){ return speaker_mute ? 1 : 0; }
#if defined(CONFIG_BADGE23_HW_GEN_P3) || defined(CONFIG_BADGE23_HW_GEN_P4) || defined(CONFIG_BADGE23_HW_GEN_P6)
static uint8_t max98091_i2c_read(const uint8_t reg)
{
const uint8_t tx[] = {reg};
uint8_t rx[1];
xSemaphoreTake(mutex_i2c, portMAX_DELAY);
esp_err_t ret = i2c_master_write_read_device(I2C_MASTER_NUM, 0x10, tx, sizeof(tx), rx, sizeof(rx), TIMEOUT_MS / portTICK_PERIOD_MS);
xSemaphoreGive(mutex_i2c);
return rx[0];
}
static esp_err_t max98091_i2c_write(const uint8_t reg, const uint8_t data)
{
const uint8_t tx[] = {reg, data};
xSemaphoreTake(mutex_i2c, portMAX_DELAY);
esp_err_t ret = i2c_master_write_to_device(I2C_MASTER_NUM, 0x10, tx, sizeof(tx), TIMEOUT_MS / portTICK_PERIOD_MS);
xSemaphoreGive(mutex_i2c);
return ret;
}
static esp_err_t max98091_i2c_write_readback(const uint8_t reg, const uint8_t data)
{
const uint8_t tx[] = {reg, data};
xSemaphoreTake(mutex_i2c, portMAX_DELAY);
esp_err_t ret = i2c_master_write_to_device(I2C_MASTER_NUM, 0x10, tx, sizeof(tx), TIMEOUT_MS / portTICK_PERIOD_MS);
xSemaphoreGive(mutex_i2c);
if(max98091_i2c_read(reg) != data) printf("readback of %04X to %02X write failed\n", data, reg);
return ret;
}
static void init_codec()
{
// Enable CODEC
vTaskDelay(10 / portTICK_PERIOD_MS);
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x00, 0x80)); // shutdown
vTaskDelay(10 / portTICK_PERIOD_MS);
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x45, 0)); // shutdown
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x1b, 1 << 4)); // pclk = mclk / 1
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x26, (1 << 7) | (1 << 6))); // music, dc filter in record
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x06, 1 << 2)); // Sets up DAI for left-justified slave mode operation.
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x07, 1 << 5)); // Sets up the DAC to speaker path
// Somehow this was needed to get an input signal to the ADC, even though
// all other registers should be taken care of later. Don't know why.
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x09, 1 << 6)); // Sets up the line in to adc path
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x25, (1 << 1) | (1 << 0))); // SDOUT, SDIN enabled
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x42, 1 << 0)); // bandgap bias
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x43, 1 << 0)); // high performane mode
// Table 51. Digital Audio Interface (DAI) Format Configuration Register
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x2E, 1)); // Left DAC -> Left Speaker
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x2F, 2)); // Right DAC -> Right Speaker
//max98091_i2c_write_readback(0x2E, (1<<2) | (1<<1)); // Line A -> Left Speaker
//max98091_i2c_write_readback(0x2F, (1<<3) | (1<<0)); // LIne B -> Right Speaker
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x29, 1)); // Left DAC -> Left HP
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x2A, 2)); // Right DAC -> Right HP
// Mic bias is off
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x3E, (1<<4) |(1<<3) | (1<<2) | (1<<1) | (1<<0))); // enable micbias, line input amps, ADCs
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x0D, (1<<3) | (1<<2))); // IN3 SE -> Line A, IN4 SE -> Line B
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x15, (1<<4) )); // line B -> left ADC
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x16, (1<<3) )); // line A -> right ADC
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x44, (1<<2) | (1<<1) | (1<<0) )); // 128x oversampling, dithering, high performance ADC
max98091_i2c_write_readback(0x13, (1<<4) | (1<<5) | (1<<1) | (1<<0) ); // enable digital mic
// Enable headset mic
#if 0
max98091_i2c_write_readback(0x13, 0);
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x0F, (0<<1) | (1<<0) )); // IN5/IN6 to MIC1
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x10, (1<<6) | (1<<4) | (1<<2) )); // 20 dB gain on MIC1
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x15, (1<<5) )); // MIC1 -> left ADC
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x16, (1<<5) )); // MIC1 -> right ADC
#endif
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x3F, (1<<1) | (1<<0))); // output enable: enable dacs
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x45, 1<<7)); // power up
//max98091_i2c_write_readback(0x31, 0x2c); // 0db, no mute
//max98091_i2c_write_readback(0x32, 0x2c); // 0db, no mute
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x3F, (1<<7) | (1<<6) | (1<<5) | (1<<4) | (1<<1) | (1<<0))); // enable outputs, dacs
//max98091_i2c_write_readback(0x27, (1<<4) | (1<<5)); // full playback gain
//max98091_i2c_write_readback(0x31, 0x3f); // +14 db speaker
//max98091_i2c_write_readback(0x32, 0x3f); // +14 db speaker
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x41, 0x0));
ESP_ERROR_CHECK(max98091_i2c_write_readback(0x3D, 1<<7)); // jack detect enable
printf("4 readbacks failing here is normal dw ^w^\n");
}
static void i2s_init(void){
init_codec();
vTaskDelay(100 / portTICK_PERIOD_MS); // dunno if necessary
static const i2s_config_t i2s_config = {
.mode = I2S_MODE_MASTER | I2S_MODE_TX,
.sample_rate = SAMPLE_RATE,
.bits_per_sample = 16,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
//.communication_format = I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB,
.communication_format = I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_LSB,
//^...technically wrong but works...? in idf v5 it's msb but don't try that late at night
.intr_alloc_flags = 0, // default interrupt priority
.dma_buf_count = DMA_BUFFER_COUNT,
.dma_buf_len = DMA_BUFFER_SIZE,
.use_apll = false
};
static const i2s_pin_config_t pin_config = {
.bck_io_num = 10,
.mck_io_num = 18,
.ws_io_num = 11,
.data_out_num = 12,
.data_in_num = I2S_PIN_NO_CHANGE
};
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);
}
// irregular register value -> vol mapping taken from codec datasheet
typedef struct {
uint8_t register_value;
float volume_dB;
} vol_map_t;
const uint8_t speaker_map_len = 40;
const vol_map_t speaker_map[] = {{0x3F, +14}, {0x3E, +13.5}, {0x3D, +13}, {0x3C, +12.5}, {0x3B, +12}, {0x3A, +11.5}, {0x39, +11}, {0x38, +10.5}, {0x37, +10}, {0x36, +9.5}, {0x35, +9}, {0x34, +8}, {0x33, +7}, {0x32, +6}, {0x31, +5}, {0x30, +4}, {0x2F, +3}, {0x2E, +2}, {0x2D, +1}, {0x2C, +0}, {0x2B, -1}, {0x2A, -2}, {0x29, -3}, {0x28, -4}, {0x27, -5}, {0x26, -6}, {0x25, -8}, {0x24, -10}, {0x23, -12}, {0x22, -14}, {0x21, -17}, {0x20, -20}, {0x1F, -23}, {0x1E, -26}, {0x1D, -29}, {0x1C, -32}, {0x1B, -36}, {0x1A, -40}, {0x19, -44}, {0x18, -48}};
const uint8_t headphones_map_len = 32;
const vol_map_t headphones_map[] = {{0x1F, +3}, {0x1E, +2.5}, {0x1D, +2}, {0x1C, +1.5}, {0x1B, +1}, {0x1A, +0}, {0x19, -1}, {0x18, -2}, {0x17, -3}, {0x16, -4}, {0x15, -5}, {0x14, -7}, {0x13, -9}, {0x12, -11}, {0x11, -13}, {0x10, -15}, {0x0F, -17}, {0x0E, -19}, {0x0D, -22}, {0x0C, -25}, {0x0B, -28}, {0x0A, -31}, {0x09, -34}, {0x08, -37}, {0x07, -40}, {0x06, -43}, {0x06, -47}, {0x04, -51}, {0x03, -55}, {0x02, -59}, {0x01, -63}, {0x00, -67}};
void _audio_headphones_set_volume_dB(float vol_dB, bool mute){
uint8_t map_index = headphones_map_len - 1;
for(; map_index; map_index--){
if(headphones_map[map_index].volume_dB >= vol_dB) break;
}
uint8_t reg = headphones_map[map_index].register_value;
reg = (mute ? (1 << 7) : 0) | reg;
max98091_i2c_write(0x2C, reg); //left chan
max98091_i2c_write(0x2D, reg); //right chan
// note: didn't check if chan physically mapped to l/r or flipped.
// do the fine steps in software
// note: synchronizing both hw and software volume changes is somewhat tricky
float hardware_volume_dB = headphones_map[map_index].volume_dB;
float software_volume_dB = vol_dB - hardware_volume_dB;
if(software_volume_dB > 0) software_volume_dB = 0;
//if(!software_volume_enabled) software_volume_dB = 0; // breaks p1, might add option once it is retired
software_volume = (int32_t) (32768 * exp(software_volume_dB * NAT_LOG_DB));
headphones_volume_dB = hardware_volume_dB + software_volume_dB;
}
void _audio_speaker_set_volume_dB(float vol_dB, bool mute){
uint8_t map_index = speaker_map_len - 1;
for(; map_index; map_index--){
if(speaker_map[map_index].volume_dB >= vol_dB) break;
}
uint8_t reg = speaker_map[map_index].register_value;
reg = (mute ? (1 << 7) : 0) | reg;
max98091_i2c_write(0x31, reg); //left chan
max98091_i2c_write(0x32, reg); //right chan
//note: didn't check if chan physically mapped to l/r or flipped.
// do the fine steps in software
// note: synchronizing both hw and software volume changes is somewhat tricky
float hardware_volume_dB = speaker_map[map_index].volume_dB;
float software_volume_dB = vol_dB - hardware_volume_dB;
if(software_volume_dB > 0) software_volume_dB = 0;
//if(!software_volume_enabled) software_volume_dB = 0; // breaks p1, might add option once it is retired
software_volume = (int32_t) (32768. * exp(software_volume_dB * NAT_LOG_DB));
speaker_volume_dB = hardware_volume_dB + software_volume_dB;
}
void audio_headphones_set_mute(uint8_t mute){
headphones_mute = mute;
audio_headphones_set_volume_dB(headphones_volume_dB);
}
void audio_speaker_set_mute(uint8_t mute){
speaker_mute = mute;
audio_speaker_set_volume_dB(speaker_volume_dB);
}
#elif defined(CONFIG_BADGE23_HW_GEN_P1)
#define MAX_VOLUME_DB 10
#define MIN_VOLUME_DB (-80)
int32_t software_volume_premute; // ugly but this is an old prototype that will be phased out soon
static void i2s_init(void){
static const i2s_config_t i2s_config = {
.mode = I2S_MODE_MASTER | I2S_MODE_TX,
.sample_rate = SAMPLE_RATE,
.bits_per_sample = 16,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
//.communication_format = I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB,
.communication_format = I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB,
.intr_alloc_flags = 0, // default interrupt priority
.dma_buf_count = DMA_BUFFER_COUNT,
.dma_buf_len = DMA_BUFFER_SIZE,
.use_apll = false
};
static const i2s_pin_config_t pin_config = {
.bck_io_num = 13,
.mck_io_num = 11,
.ws_io_num = 12,
.data_out_num = 14,
.data_in_num = I2S_PIN_NO_CHANGE
};
i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);
}
void _audio_speaker_set_volume_dB(float vol_dB, bool mute){
int32_t buf = 32767 * exp(vol_dB * NAT_LOG_DB);
software_volume_premute = buf;
if(mute){
software_volume = 0;
} else {
software_volume = software_volume_premute;
}
speaker_volume_dB = vol_dB;
}
void _audio_headphones_set_volume_dB(float vol_dB, bool mute){
}
void audio_headphones_set_mute(uint8_t mute){
headphones_mute = 1;
};
void audio_speaker_set_mute(uint8_t mute){
speaker_mute = mute;
if(speaker_mute){
software_volume = 0;
} else {
software_volume = software_volume_premute;
}
}
#else
#error "audio not implemented for this badge generation"
#endif
float audio_speaker_set_volume_dB(float vol_dB){
bool mute = speaker_mute || audio_headphones_are_connected();
if(vol_dB > speaker_maximum_volume_user_dB) vol_dB = speaker_maximum_volume_user_dB;
if(vol_dB < speaker_minimum_volume_user_dB){
vol_dB = SILLY_LOW_VOLUME_DB; // fake mute
mute = 1;
}
_audio_speaker_set_volume_dB(vol_dB, mute);
return speaker_volume_dB;
}
float audio_headphones_set_volume_dB(float vol_dB){
bool mute = headphones_mute || (!audio_headphones_are_connected());
if(vol_dB > headphones_maximum_volume_user_dB) vol_dB = headphones_maximum_volume_user_dB;
if(vol_dB < headphones_minimum_volume_user_dB){
vol_dB = SILLY_LOW_VOLUME_DB; // fake mute
mute = 1;
}
_audio_headphones_set_volume_dB(vol_dB, mute);
return headphones_volume_dB;
}
void audio_headphones_detection_override(uint8_t enable){
headphones_detection_override = enable;
audio_headphones_set_volume_dB(headphones_volume_dB);
audio_speaker_set_volume_dB(speaker_volume_dB);
}
float audio_headphones_adjust_volume_dB(float vol_dB){
if(audio_headphones_get_volume_dB() < headphones_minimum_volume_user_dB){ //fake mute
if(vol_dB > 0){
return audio_headphones_set_volume_dB(headphones_minimum_volume_user_dB);
} else {
return audio_headphones_get_volume_dB();
}
} else {
return audio_headphones_set_volume_dB(headphones_volume_dB + vol_dB);
}
}
float audio_speaker_adjust_volume_dB(float vol_dB){
if(audio_speaker_get_volume_dB() < speaker_minimum_volume_user_dB){ //fake mute
if(vol_dB > 0){
return audio_speaker_set_volume_dB(speaker_minimum_volume_user_dB);
printf("hi");
} else {
return audio_speaker_get_volume_dB();
}
} else {
return audio_speaker_set_volume_dB(speaker_volume_dB + vol_dB);
}
}
float audio_adjust_volume_dB(float vol_dB){
if(audio_headphones_are_connected()){
return audio_headphones_adjust_volume_dB(vol_dB);
} else {
return audio_speaker_adjust_volume_dB(vol_dB);
}
}
float audio_set_volume_dB(float vol_dB){
if(audio_headphones_are_connected()){
return audio_headphones_set_volume_dB(vol_dB);
} else {
return audio_speaker_set_volume_dB(vol_dB);
}
}
float audio_get_volume_dB(){
if(audio_headphones_are_connected()){
return audio_headphones_get_volume_dB();
} else {
return audio_speaker_get_volume_dB();
}
}
void audio_set_mute(uint8_t mute){
if(audio_headphones_are_connected()){
audio_headphones_set_mute(mute);
} else {
audio_speaker_set_mute(mute);
}
}
uint8_t audio_get_mute(){
if(audio_headphones_are_connected()){
return audio_headphones_get_mute();
} else {
return audio_speaker_get_mute();
}
}
float audio_headphones_set_maximum_volume_dB(float vol_dB){
if(vol_dB > headphones_maximum_volume_system_dB) vol_dB = headphones_maximum_volume_system_dB;
if(vol_dB < headphones_minimum_volume_user_dB) vol_dB = headphones_minimum_volume_user_dB;
headphones_maximum_volume_user_dB = vol_dB;
return headphones_maximum_volume_user_dB;
}
float audio_headphones_set_minimum_volume_dB(float vol_dB){
if(vol_dB > headphones_maximum_volume_user_dB) vol_dB = headphones_maximum_volume_user_dB;
if((vol_dB + 1) < SILLY_LOW_VOLUME_DB) vol_dB = SILLY_LOW_VOLUME_DB + 1.;
headphones_minimum_volume_user_dB = vol_dB;
return headphones_minimum_volume_user_dB;
}
float audio_speaker_set_maximum_volume_dB(float vol_dB){
if(vol_dB > speaker_maximum_volume_system_dB) vol_dB = speaker_maximum_volume_system_dB;
if(vol_dB < speaker_minimum_volume_user_dB) vol_dB = speaker_minimum_volume_user_dB;
speaker_maximum_volume_user_dB = vol_dB;
return speaker_maximum_volume_user_dB;
}
float audio_speaker_set_minimum_volume_dB(float vol_dB){
if(vol_dB > speaker_maximum_volume_user_dB) vol_dB = speaker_maximum_volume_user_dB;
if((vol_dB + 1) < SILLY_LOW_VOLUME_DB) vol_dB = SILLY_LOW_VOLUME_DB + 1.;
speaker_minimum_volume_user_dB = vol_dB;
return speaker_minimum_volume_user_dB;
}
float audio_speaker_get_volume_relative(){
float ret = audio_speaker_get_volume_dB();
if(ret < speaker_minimum_volume_user_dB) return 0; // fake mute
float vol_range = speaker_maximum_volume_user_dB - speaker_minimum_volume_user_dB;
ret -= speaker_minimum_volume_user_dB; // shift to above zero
ret /= vol_range; // restrict to 0..1 range
return (ret*0.99) + 0.01; // shift to 0.01 to 0.99 range to distinguish from fake mute
}
float audio_headphones_get_volume_relative(){
float ret = audio_headphones_get_volume_dB();
if(ret < headphones_minimum_volume_user_dB) return 0; // fake mute
float vol_range = headphones_maximum_volume_user_dB - headphones_minimum_volume_user_dB;
ret -= headphones_minimum_volume_user_dB; // shift to above zero
ret /= vol_range; // restrict to 0..1 range
return (ret*0.99) + 0.01; // shift to 0.01 to 0.99 range to distinguish from fake mute
}
float audio_get_volume_relative(){
if(audio_headphones_are_connected()){
return audio_headphones_get_volume_relative();
} else {
return audio_speaker_get_volume_relative();
}
}
void audio_update_jacksense(){
#if defined(CONFIG_BADGE23_HW_GEN_P1)
line_in_connected = 0;
#elif defined(CONFIG_BADGE23_HW_GEN_P3) || defined(CONFIG_BADGE23_HW_GEN_P4)
line_in_connected = 1;
#elif defined(CONFIG_BADGE23_HW_GEN_P6)
line_in_connected = 0; //TODO: read port expander
#endif
#if defined(CONFIG_BADGE23_HW_GEN_P1)
headphones_connected = 0;
headset_connected = 0;
#elif defined(CONFIG_BADGE23_HW_GEN_P3) || defined(CONFIG_BADGE23_HW_GEN_P4) || defined(CONFIG_BADGE23_HW_GEN_P6)
static uint8_t jck_prev = 255; // unreachable value -> initial comparision always untrue
uint8_t jck = max98091_i2c_read(0x02);
if(jck == 6){
headphones_connected = 0;
headset_connected = 0;
} else if(jck == 0){
headphones_connected = 1;
headset_connected = 0;
} else if(jck == 2){
headphones_connected = 1;
headset_connected = 1;
}
if(jck != jck_prev){ // update volume to trigger mutes if needed
audio_speaker_set_volume_dB(speaker_volume_dB);
audio_headphones_set_volume_dB(headphones_volume_dB);
}
jck_prev = jck;
#endif
}
typedef struct _audio_source_t{
void * render_data;
float (* render_function)(void *);
uint16_t index;
struct _audio_source_t * next;
} audio_source_t;
static audio_source_t * _audio_sources = NULL;
uint16_t add_audio_source(void * render_data, void * render_function){
//construct audio source struct
audio_source_t * src = malloc(sizeof(audio_source_t));
if(src == NULL) return;
src->render_data = render_data;
src->render_function = render_function;
src->next = NULL;
src->index = 0;
//handle empty list special case
if(_audio_sources == NULL){
_audio_sources = src;
return 0; //only nonempty lists from here on out!
}
//searching for lowest unused index
audio_source_t * index_source = _audio_sources;
while(1){
if(src->index == (index_source->index)){
src->index++; //someone else has index already, try next
index_source = _audio_sources; //start whole list for new index
} else {
index_source = index_source->next;
}
if(index_source == NULL){ //traversed the entire list
break;
}
}
audio_source_t * audio_source = _audio_sources;
//append new source to linked list
while(audio_source != NULL){
if(audio_source->next == NULL){
audio_source->next = src;
break;
} else {
audio_source = audio_source->next;
}
}
return src->index;
}
void remove_audio_source(uint16_t index){
audio_source_t * audio_source = _audio_sources;
audio_source_t * start_gap = NULL;
while(audio_source != NULL){
if(index == audio_source->index){
if(start_gap == NULL){
_audio_sources = audio_source->next;
} else {
start_gap->next = audio_source->next;
}
vTaskDelay(20 / portTICK_PERIOD_MS); //give other tasks time to stop using
free(audio_source); //terrible hack tbh
break;
}
start_gap = audio_source;
audio_source = audio_source->next;
}
}
uint16_t count_audio_sources(){
uint16_t ret = 0;
audio_source_t * audio_source = _audio_sources;
while(audio_source != NULL){
audio_source = audio_source->next;
ret++;
}
return ret;
}
static void _audio_init(void) {
st3m_scope_init();
// TODO: this assumes I2C is already initialized
i2s_init();
audio_update_jacksense();
//ESP_ERROR_CHECK(i2s_channel_enable(tx_chan));
TaskHandle_t handle;
xTaskCreate(&audio_player_task, "Audio player", 3000, NULL, configMAX_PRIORITIES - 1, &handle);
}
static void audio_player_task(void* arg) {
int16_t buffer[DMA_BUFFER_SIZE * 2];
memset(buffer, 0, sizeof(buffer));
while(true) {
for(int i = 0; i < (DMA_BUFFER_SIZE * 2); i += 2){
float sample = 0;
audio_source_t * audio_source = _audio_sources;
while(audio_source != NULL){
sample += (*(audio_source->render_function))(audio_source->render_data);
audio_source = audio_source->next;
}
st3m_scope_write((int16_t) (1600. * sample));
sample = software_volume * (sample/10);
if(sample > 32767) sample = 32767;
if(sample < -32767) sample = -32767;
buffer[i] = (int16_t) sample;
buffer[i+1] = buffer[i];
}
size_t count = 0;
i2s_write(I2S_PORT, buffer, sizeof(buffer), &count, 1000);
if (count != sizeof(buffer)) {
printf("i2s_write_bytes: count (%d) != length (%d)\n", count, sizeof(buffer));
abort();
}
}
}
void audio_init() { _audio_init(); }
//#include <stdio.h>
//#include <string.h>
#include "esp_log.h"
#include "driver/i2c.h"
#include <stdint.h>
#include <freertos/FreeRTOS.h>
#include <freertos/atomic.h>
#include "badge23/lock.h"
#define PETAL_PAD_TIP 0
#define PETAL_PAD_CCW 1
#define PETAL_PAD_CW 2
#define PETAL_PAD_BASE 3
#define CIN CDC_NONE 0
#define CIN_CDC_NEG 1
#define CIN_CDC_POS 2
#define CIN_BIAS 3
#define AFE_INCR_CAP 1000
#if defined(CONFIG_BADGE23_HW_GEN_P3) || defined(CONFIG_BADGE23_HW_GEN_P4) || defined(CONFIG_BADGE23_HW_GEN_P6)
static const uint8_t top_map[] = {0, 0, 0, 2, 2, 2, 6, 6, 6, 4, 4, 4};
static const uint8_t top_stages = 12;
static const uint8_t bot_map[] = {1, 1, 3, 3, 5, 7, 7, 9, 9, 8, 8, 8};
static const uint8_t bot_stages = 12;
static const uint8_t bot_stage_config[] = {0,1,2,3,5,6,7,8,9,10,11,12};
#define DEFAULT_THRES_TOP 8000
#define DEFAULT_THRES_BOT 12000
#elif defined(CONFIG_BADGE23_HW_GEN_P1)
static const uint8_t top_map[] = {2, 2, 2, 0, 0, 8, 8, 8, 6, 6, 4, 4};
static const uint8_t top_stages = 12;
static const uint8_t bot_map[] = {1, 1, 3, 3, 5, 5, 7, 7, 9, 9};
static const uint8_t bot_stages = 10;
static const uint8_t top_segment_map[] = {1,2,0,1,2,1,2,0,1,2,1,2}; //idk
static const uint8_t bot_segment_map[] = {3,0,3,0,3,0,0,3,0,3}; //idk
static const uint8_t bot_stage_config[] = {0,1,2,3,4,5,6,7,8,9,10,11};
#define DEFAULT_THRES_TOP 2000
#define DEFAULT_THRES_BOT 12000
#define AD7147_ADDR_TOP 0b101101
#define AD7147_ADDR_BOT 0b101100
#else
#error "captouch not implemented for this badge generation"
#endif
#if defined(CONFIG_BADGE23_HW_GEN_P4)
#define AD7147_ADDR_TOP 0b101100
#define AD7147_ADDR_BOT 0b101101
static const uint8_t top_segment_map[] = {1,3,2,2,3,1,1,3,2,1,3,2}; //PETAL_PAD_*
static const uint8_t bot_segment_map[] = {3,0,3,0,0,0,3,0,3,1,2,3}; //PETAL_PAD_*
#elif defined(CONFIG_BADGE23_HW_GEN_P6)
#define AD7147_ADDR_TOP 0b101100
#define AD7147_ADDR_BOT 0b101101
static const uint8_t top_segment_map[] = {1,3,2,2,3,1,1,3,2,1,3,2}; //PETAL_PAD_*
static const uint8_t bot_segment_map[] = {3,0,3,0,0,0,3,0,3,1,2,3}; //PETAL_PAD_*
#elif defined(CONFIG_BADGE23_HW_GEN_P3)
#define AD7147_ADDR_TOP 0b101101
#define AD7147_ADDR_BOT 0b101100
static const uint8_t top_segment_map[] = {0,1,2, 2,1,0, 0,1,2, 2,1,0}; //PETAL_PAD_*
static const uint8_t bot_segment_map[] = {3,0,3,0,0,0,3,0,3, 0,2,1}; //PETAL_PAD_*
#endif
static const char *TAG = "captouch";
#define I2C_MASTER_NUM 0 /*!< I2C master i2c port number, the number of i2c peripheral interfaces available will depend on the chip */
#define AD7147_REG_PWR_CONTROL 0x00
#define AD7147_REG_STAGE_CAL_EN 0x01
#define AD7147_REG_STAGE_HIGH_INT_ENABLE 0x06
#define AD7147_REG_DEVICE_ID 0x17
#define TIMEOUT_MS 1000
#define PETAL_PRESSED_DEBOUNCE 2
static struct ad714x_chip *chip_top;
static struct ad714x_chip *chip_bot;
typedef struct{
uint8_t config_mask;
uint16_t amb_values[4]; //ordered according to PETAL_PAD_*
uint16_t cdc_values[4]; //ordered according to PETAL_PAD_*
uint16_t thres_values[4]; //ordered according to PETAL_PAD_*
uint8_t pressed;
} petal_t;
static petal_t petals[10];
struct ad714x_chip {
uint8_t addr;
uint8_t gpio;
int pos_afe_offsets[13];
int neg_afe_offsets[13];
int neg_afe_offset_swap;
int stages;
};
static struct ad714x_chip chip_top_rev5 = {.addr = AD7147_ADDR_TOP, .gpio = 15,
.pos_afe_offsets = {4, 2, 2, 2, 2, 3, 4, 2, 2, 2, 2, 0},
.stages=top_stages};
static struct ad714x_chip chip_bot_rev5 = {.addr = AD7147_ADDR_BOT, .gpio = 15,
.pos_afe_offsets = {3, 2, 1, 1 ,1, 1, 1, 1, 2, 3, 3, 3},
.stages=bot_stages};
static esp_err_t ad714x_i2c_write(const struct ad714x_chip *chip, const uint16_t reg, const uint16_t data)
{
const uint8_t tx[] = {reg >> 8, reg & 0xFF, data >> 8, data & 0xFF};
xSemaphoreTake(mutex_i2c, portMAX_DELAY);
ESP_LOGI(TAG, "AD7147 write reg %X-> %X", reg, data);
xSemaphoreGive(mutex_i2c);
return i2c_master_write_to_device(I2C_MASTER_NUM, chip->addr, tx, sizeof(tx), TIMEOUT_MS / portTICK_PERIOD_MS);
}
static esp_err_t ad714x_i2c_read(const struct ad714x_chip *chip, const uint16_t reg, uint16_t *data, const size_t len)
{
const uint8_t tx[] = {reg >> 8, reg & 0xFF};
uint8_t rx[len * 2];
xSemaphoreTake(mutex_i2c, portMAX_DELAY);
esp_err_t ret = i2c_master_write_read_device(I2C_MASTER_NUM, chip->addr, tx, sizeof(tx), rx, sizeof(rx), TIMEOUT_MS / portTICK_PERIOD_MS);
xSemaphoreGive(mutex_i2c);
for(int i = 0; i < len; i++) {
data[i] = (rx[i * 2] << 8) | rx[i * 2 + 1];
}
return ret;
}
struct ad7147_stage_config {
unsigned int cinX_connection_setup[13];
unsigned int se_connection_setup:2;
unsigned int neg_afe_offset_disable:1;
unsigned int pos_afe_offset_disable:1;
unsigned int neg_afe_offset:6;
unsigned int neg_afe_offset_swap:1;
unsigned int pos_afe_offset:6;
unsigned int pos_afe_offset_swap:1;
unsigned int neg_threshold_sensitivity:4;
unsigned int neg_peak_detect:3;
unsigned int pos_threshold_sensitivity:4;
unsigned int pos_peak_detect:3;
};
static const uint16_t bank2 = 0x80;
static void ad714x_set_stage_config(const struct ad714x_chip *chip, const uint8_t stage, const struct ad7147_stage_config * config)
{
const uint16_t connection_6_0 = (config->cinX_connection_setup[6] << 12) | (config->cinX_connection_setup[5] << 10) | (config->cinX_connection_setup[4] << 8) | (config->cinX_connection_setup[3] << 6) | (config->cinX_connection_setup[2] << 4) | (config->cinX_connection_setup[1] << 2) | (config->cinX_connection_setup[0] << 0);
const uint16_t connection_12_7 = (config->pos_afe_offset_disable << 15) | (config->neg_afe_offset_disable << 14) | (config->se_connection_setup << 12) | (config->cinX_connection_setup[12] << 10) | (config->cinX_connection_setup[11] << 8) | (config->cinX_connection_setup[10] << 6) | (config->cinX_connection_setup[9] << 4) | (config->cinX_connection_setup[8] << 2) | (config->cinX_connection_setup[7] << 0);
const uint16_t afe_offset = (config->pos_afe_offset_swap << 15) | (config->pos_afe_offset << 8) | (config->neg_afe_offset_swap << 7) | (config->neg_afe_offset << 0);
const uint16_t sensitivity = (config->pos_peak_detect << 12) | (config->pos_threshold_sensitivity << 8) | (config->neg_peak_detect << 4) | (config->neg_threshold_sensitivity << 0);
//ESP_LOGI(TAG, "Stage %d config-> %X %X %X %X", stage, connection_6_0, connection_12_7, afe_offset, sensitivity);
//ESP_LOGI(TAG, "Config: %X %X %X %X %X %X %X %X %X", config->pos_afe_offset_disable, config->pos_afe_offset_disable, config->se_connection_setup, config->cinX_connection_setup[12], config->cinX_connection_setup[11], config->cinX_connection_setup[10], config->cinX_connection_setup[9], config->cinX_connection_setup[8], config->cinX_connection_setup[7]);
ad714x_i2c_write(chip, bank2 + stage * 8, connection_6_0);
ad714x_i2c_write(chip, bank2 + stage * 8 + 1, connection_12_7);
ad714x_i2c_write(chip, bank2 + stage * 8 + 2, afe_offset);
ad714x_i2c_write(chip, bank2 + stage * 8 + 3, sensitivity);
}
struct ad7147_device_config {
unsigned int power_mode:2;
unsigned int lp_conv_delay:2;
unsigned int sequence_stage_num:4;
unsigned int decimation:2;
unsigned int sw_reset:1;
unsigned int int_pol:1;
unsigned int ext_source:1;
unsigned int cdc_bias:2;
unsigned int stage0_cal_en:1;
unsigned int stage1_cal_en:1;
unsigned int stage2_cal_en:1;
unsigned int stage3_cal_en:1;
unsigned int stage4_cal_en:1;
unsigned int stage5_cal_en:1;
unsigned int stage6_cal_en:1;
unsigned int stage7_cal_en:1;
unsigned int stage8_cal_en:1;
unsigned int stage9_cal_en:1;
unsigned int stage10_cal_en:1;
unsigned int stage11_cal_en:1;
unsigned int avg_fp_skip:2;
unsigned int avg_lp_skip:2;
unsigned int stage0_high_int_enable:1;
unsigned int stage1_high_int_enable:1;
unsigned int stage2_high_int_enable:1;
unsigned int stage3_high_int_enable:1;
unsigned int stage4_high_int_enable:1;
unsigned int stage5_high_int_enable:1;
unsigned int stage6_high_int_enable:1;
unsigned int stage7_high_int_enable:1;
unsigned int stage8_high_int_enable:1;
unsigned int stage9_high_int_enable:1;
unsigned int stage10_high_int_enable:1;
unsigned int stage11_high_int_enable:1;
};
static void ad714x_set_device_config(const struct ad714x_chip *chip, const struct ad7147_device_config * config)
{
const uint16_t pwr_control = (config->cdc_bias << 14) | (config->ext_source << 12) | (config->int_pol << 11) | (config->sw_reset << 10) | (config->decimation << 8) | (config->sequence_stage_num << 4) | (config->lp_conv_delay << 2) | (config->power_mode << 0);
const uint16_t stage_cal_en = (config->avg_lp_skip << 14) | (config->avg_fp_skip << 12) | (config->stage11_cal_en << 11) | (config->stage10_cal_en << 10) | (config->stage9_cal_en << 9) | (config->stage8_cal_en << 8) | (config->stage7_cal_en << 7) | (config->stage6_cal_en << 6) | (config->stage5_cal_en << 5) | (config->stage4_cal_en << 4) | (config->stage3_cal_en << 3) | (config->stage2_cal_en << 2) | (config->stage1_cal_en << 1) | (config->stage0_cal_en << 0);
const uint16_t stage_high_int_enable = (config->stage11_high_int_enable << 11) | (config->stage10_high_int_enable << 10) | (config->stage9_high_int_enable << 9) | (config->stage8_high_int_enable << 8) | (config->stage7_high_int_enable << 7) | (config->stage6_high_int_enable << 6) | (config->stage5_high_int_enable << 5) | (config->stage4_high_int_enable << 4) | (config->stage3_high_int_enable << 3) | (config->stage2_high_int_enable << 2) | (config->stage1_high_int_enable << 1) | (config->stage0_high_int_enable << 0);
ad714x_i2c_write(chip, AD7147_REG_PWR_CONTROL, pwr_control);
ad714x_i2c_write(chip, AD7147_REG_STAGE_CAL_EN, stage_cal_en);
ad714x_i2c_write(chip, AD7147_REG_STAGE_HIGH_INT_ENABLE, stage_high_int_enable);
}
static struct ad7147_stage_config ad714x_default_config(void)
{
return (struct ad7147_stage_config) {
.cinX_connection_setup={CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS, CIN_BIAS},
.se_connection_setup=0b01,
.pos_afe_offset=0,
};
}
static void captouch_configure_stage(struct ad714x_chip * chip, uint8_t stage){
struct ad7147_stage_config stage_config;
stage_config = ad714x_default_config();
if(chip == chip_bot){
stage_config.cinX_connection_setup[bot_stage_config[stage]] = CIN_CDC_POS;
} else {
stage_config.cinX_connection_setup[stage] = CIN_CDC_POS;
}
stage_config.pos_afe_offset=chip->pos_afe_offsets[stage];
ad714x_set_stage_config(chip, stage, &stage_config);
}
static int8_t captouch_configure_stage_afe_offset(uint8_t top, uint8_t stage, int8_t delta_afe){
int8_t sat = 0;
struct ad714x_chip * chip = chip_bot;
if(top) chip = chip_top;
int8_t afe = chip->pos_afe_offsets[stage] - chip->neg_afe_offsets[stage];
if((afe >= 63) && (delta_afe > 0)) sat = 1;
if((afe <= 63) && (delta_afe < 0)) sat = -1;
afe += delta_afe;
if(afe >= 63) afe = 63;
if(afe <= -63)afe = -63;
if(afe>0){
chip->pos_afe_offsets[stage] = afe;
chip->neg_afe_offsets[stage] = 0;
} else {
chip->pos_afe_offsets[stage] = 0;
chip->neg_afe_offsets[stage] = -afe;
}
captouch_configure_stage(chip, stage);
return sat;
}
static void captouch_init_chip(struct ad714x_chip* chip, const struct ad7147_device_config device_config)
{
uint16_t data;
ad714x_i2c_read(chip, AD7147_REG_DEVICE_ID, &data, 1);
ESP_LOGI(TAG, "DEVICE ID = %X", data);
ad714x_set_device_config(chip, &device_config);
for(int i=0; i<chip->stages; i++) {
captouch_configure_stage(chip, i);
}
}
static void captouch_init_petals(){
for(int i = 0; i < 10; i++){
for(int j = 0; j < 4; j++){
petals[i].amb_values[j] = 0;
petals[i].cdc_values[j] = 0;
if(i%2){
petals[i].thres_values[j] = DEFAULT_THRES_BOT;
} else {
petals[i].thres_values[j] = DEFAULT_THRES_TOP;
}
}
petals[i].config_mask = 0;
}
for(int i = 0; i < bot_stages; i++){
petals[bot_map[i]].config_mask |= 1 << bot_segment_map[i];
}
for(int i = 0; i < top_stages; i++){
petals[top_map[i]].config_mask |= 1 << top_segment_map[i];
}
}
int32_t captouch_get_petal_rad(uint8_t petal){
if(petal > 9) petal = 9;
uint8_t cf = petals[petal].config_mask;
if(cf == 0b1110){ //CCW, CW, BASE
int32_t left = petals[petal].cdc_values[PETAL_PAD_CCW];
left -= petals[petal].amb_values[PETAL_PAD_CCW];
int32_t right = petals[petal].cdc_values[PETAL_PAD_CW];
right -= petals[petal].amb_values[PETAL_PAD_CW];
int32_t base = petals[petal].cdc_values[PETAL_PAD_BASE];
base -= petals[petal].amb_values[PETAL_PAD_BASE];
return (left + right)/2 - base;
}
if(cf == 0b111){ //CCW, CW, TIP
int32_t left = petals[petal].cdc_values[PETAL_PAD_CCW];
left -= petals[petal].amb_values[PETAL_PAD_CCW];
int32_t right = petals[petal].cdc_values[PETAL_PAD_CW];
right -= petals[petal].amb_values[PETAL_PAD_CW];
int32_t tip = petals[petal].cdc_values[PETAL_PAD_TIP];
tip -= petals[petal].amb_values[PETAL_PAD_TIP];
return (-left - right)/2 + tip;
}
if(cf == 0b1001){ //TIP, BASE
int32_t tip = petals[petal].cdc_values[PETAL_PAD_TIP];
tip -= petals[petal].amb_values[PETAL_PAD_TIP];
int32_t base = petals[petal].cdc_values[PETAL_PAD_BASE];
base -= petals[petal].amb_values[PETAL_PAD_BASE];
return tip - base;
}
if(cf == 0b1){ //TIP
int32_t tip = petals[petal].cdc_values[PETAL_PAD_TIP];
tip -= petals[petal].amb_values[PETAL_PAD_TIP];
return tip;
}
return 0;
}
int32_t captouch_get_petal_phi(uint8_t petal){
if(petal > 9) petal = 9;
uint8_t cf = petals[petal].config_mask;
if((cf == 0b1110) || (cf == 0b110) || (cf == 0b111)){ //CCW, CW, (BASE)
int32_t left = petals[petal].cdc_values[PETAL_PAD_CCW];
left -= petals[petal].amb_values[PETAL_PAD_CCW];
int32_t right = petals[petal].cdc_values[PETAL_PAD_CW];
right -= petals[petal].amb_values[PETAL_PAD_CW];
return left - right;
}
return 0;
}
void captouch_init(void)
{
captouch_init_petals();
chip_top = &chip_top_rev5;
chip_bot = &chip_bot_rev5;
captouch_init_chip(chip_top, (struct ad7147_device_config){.sequence_stage_num = 11,
.decimation = 1,
});
captouch_init_chip(chip_bot, (struct ad7147_device_config){.sequence_stage_num = 11,
.decimation = 1,
});
}
uint16_t read_captouch(){
uint16_t bin_petals = 0;
for(int i = 0; i < 10; i++) {
if(petals[i].pressed){
bin_petals |= (1<<i);
}
}
return bin_petals;
}
uint16_t cdc_data[2][12] = {0,};
uint16_t cdc_ambient[2][12] = {0,};
static volatile uint32_t calib_active = 0;
static uint8_t calib_cycles = 0;
void captouch_force_calibration(){
if(!calib_cycles){ //last calib has finished
calib_cycles = 16; //goal cycles, can be argument someday
Atomic_Increment_u32(&calib_active);
}
}
uint8_t captouch_calibration_active(){
return Atomic_CompareAndSwap_u32(&calib_active, 0, 0) == ATOMIC_COMPARE_AND_SWAP_FAILURE;
}
void check_petals_pressed(){
for(int i = 0; i < 10; i++){
bool pressed = 0;
bool prev = petals[i].pressed;
for(int j = 0; j < 4; j++){
if((petals[i].amb_values[j] +
petals[i].thres_values[j]) <
petals[i].cdc_values[j]){
pressed = 1;
}
}
if(pressed){
petals[i].pressed = PETAL_PRESSED_DEBOUNCE;
} else if(petals[i].pressed){
petals[i].pressed--;
}
if(petals[i].pressed && (!prev)){
// TODO: PETAL_PRESS_CALLBACK
}
if((!petals[i].pressed) && prev){
// TODO: PETAL_RELEASE_CALLBACK
}
}
}
void cdc_to_petal(bool bot, bool amb, uint16_t cdc_data[], uint8_t cdc_data_length){
if(!bot){
for(int i = 0; i < cdc_data_length; i++){
if(amb){
petals[top_map[i]].amb_values[top_segment_map[i]] = cdc_data[i];
} else {
petals[top_map[i]].cdc_values[top_segment_map[i]] = cdc_data[i];
}
}
} else {
for(int i = 0; i < cdc_data_length; i++){
if(amb){
petals[bot_map[i]].amb_values[bot_segment_map[i]] = cdc_data[i];
} else {
petals[bot_map[i]].cdc_values[bot_segment_map[i]] = cdc_data[i];
}
}
}
}
uint16_t captouch_get_petal_pad_raw(uint8_t petal, uint8_t pad){
if(petal > 9) petal = 9;
if(pad > 3) pad = 3;
return petals[petal].cdc_values[pad];
}
uint16_t captouch_get_petal_pad_calib_ref(uint8_t petal, uint8_t pad){
if(petal > 9) petal = 9;
if(pad > 3) pad = 3;
return petals[petal].amb_values[pad];
}
uint16_t captouch_get_petal_pad(uint8_t petal, uint8_t pad){
if(petal > 9) petal = 9;
if(pad > 3) pad = 3;
if(petals[petal].amb_values[pad] < petals[petal].cdc_values[pad]){
return petals[petal].cdc_values[pad] - petals[petal].amb_values[pad];
}
return 0;
}
void captouch_set_petal_pad_threshold(uint8_t petal, uint8_t pad, uint16_t thres){
if(petal > 9) petal = 9;
if(pad > 3) pad = 3;
petals[petal].thres_values[pad] = thres;
}
static int32_t calib_target = 6000;
void captouch_set_calibration_afe_target(uint16_t target){
calib_target = target;
}
void captouch_read_cycle(){
static uint8_t calib_cycle = 0;
static uint8_t calib_div = 1;
static uint32_t ambient_acc[2][12] = {{0,}, {0,}};
if(calib_cycles){
if(calib_cycle == 0){ // last cycle has finished, setup new
calib_cycle = calib_cycles;
calib_div = calib_cycles;
for(int j=0;j<12;j++){
ambient_acc[0][j] = 0;
ambient_acc[1][j] = 0;
}
}
ad714x_i2c_read(chip_top, 0xB, cdc_ambient[0], chip_top->stages);
ad714x_i2c_read(chip_bot, 0xB, cdc_ambient[1], chip_bot->stages);
for(int j=0;j<12;j++){
ambient_acc[0][j] += cdc_ambient[0][j];
ambient_acc[1][j] += cdc_ambient[1][j];
}
// TODO: use median instead of average
calib_cycle--;
if(!calib_cycle){ //calib cycle is complete
for(int i = 0; i < 12; i++){
cdc_ambient[0][i] = ambient_acc[0][i] / calib_div;
cdc_ambient[1][i] = ambient_acc[1][i] / calib_div;
}
cdc_to_petal(0, 1, cdc_ambient[0], 12);
cdc_to_petal(1, 1, cdc_ambient[1], 12);
calib_cycles = 0;
uint8_t recalib = 0;
for(int i = 0; i < 12; i++){
for(int j = 0; j < 2; j++){
int32_t diff = ((int32_t) cdc_ambient[j][i]) - calib_target;
int8_t steps = diff/(AFE_INCR_CAP);
if((steps > 1) || (steps < -1)){
if(!captouch_configure_stage_afe_offset(1-j, i, steps)){
recalib = 1;
}
}
}
}
if(recalib){
calib_cycles = 16; // do another round
} else {
Atomic_Decrement_u32(&calib_active);
}
}
} else {
ad714x_i2c_read(chip_top, 0xB, cdc_data[0], chip_top->stages);
cdc_to_petal(0, 0, cdc_data[0], 12);
ad714x_i2c_read(chip_bot, 0xB, cdc_data[1], chip_bot->stages);
cdc_to_petal(1, 0, cdc_data[1], 12);
check_petals_pressed();
}
}
static void captouch_print_debug_info_chip(const struct ad714x_chip* chip)
{
uint16_t *data;
uint16_t *ambient;
const int stages = chip->stages;
if(chip == chip_top) {
data = cdc_data[0];
ambient = cdc_ambient[0];
} else {
data = cdc_data[1];
ambient = cdc_ambient[1];
}
ESP_LOGI(TAG, "CDC results: %X %X %X %X %X %X %X %X %X %X %X %X", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11]);
for(int stage=0; stage<stages; stage++) {
ESP_LOGI(TAG, "stage %d ambient: %X diff: %d", stage, ambient[stage], data[stage] - ambient[stage]);
}
}
void captouch_print_debug_info(void)
{
captouch_print_debug_info_chip(chip_top);
captouch_print_debug_info_chip(chip_bot);
}
#include "badge23/captouch.h"
#include "badge23/audio.h"
#include "badge23/leds.h"
#include "badge23/spio.h"
#include "badge23/lock.h"
#include "flow3r_bsp.h"
#include "st3m_gfx.h"
#include "st3m_fs.h"
#include "esp_log.h"
#include "driver/i2c.h"
#include "driver/spi_master.h"
#include "freertos/timers.h"
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdint.h>
static const char *TAG = "espan";
#define I2C_MASTER_NUM 0 /*!< I2C master i2c port number, the number of i2c peripheral interfaces available will depend on the chip */
#define I2C_MASTER_FREQ_HZ 400000 /*!< I2C master clock frequency */
#define I2C_MASTER_TX_BUF_DISABLE 0 /*!< I2C master doesn't need buffer */
#define I2C_MASTER_RX_BUF_DISABLE 0 /*!< I2C master doesn't need buffer */
#if defined(CONFIG_BADGE23_HW_GEN_P3) || defined(CONFIG_BADGE23_HW_GEN_P4) || defined(CONFIG_BADGE23_HW_GEN_P6)
#define CONFIG_I2C_MASTER_SDA 2
#define CONFIG_I2C_MASTER_SCL 1
#elif defined(CONFIG_BADGE23_HW_GEN_P1)
#define CONFIG_I2C_MASTER_SDA 10
#define CONFIG_I2C_MASTER_SCL 9
#else
#error "i2c not implemented for this badge generation"
#endif
static esp_err_t i2c_master_init(void)
{
int i2c_master_port = I2C_MASTER_NUM;
i2c_config_t conf = {
.mode = I2C_MODE_MASTER,
.sda_io_num = CONFIG_I2C_MASTER_SDA,
.scl_io_num = CONFIG_I2C_MASTER_SCL,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master.clk_speed = I2C_MASTER_FREQ_HZ,
};
i2c_param_config(i2c_master_port, &conf);
return i2c_driver_install(i2c_master_port, conf.mode, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0);
}
static uint8_t hw_init_done = 0;
static void io_fast_task(void * data){
TickType_t last_wake = xTaskGetTickCount();
while(1) {
vTaskDelayUntil(&last_wake, pdMS_TO_TICKS(10)); // 100 Hz
captouch_read_cycle();
update_button_state();
}
}
// read out stuff like jack detection, battery status, usb connection etc.
static void io_slow_task(void * data){
TickType_t last_wake = xTaskGetTickCount();
while(1) {
vTaskDelayUntil(&last_wake, pdMS_TO_TICKS(100)); // 10 Hz
audio_update_jacksense();
leds_update_hardware();
}
}
void locks_init(){
mutex_i2c = xSemaphoreCreateMutex();
mutex_LED = xSemaphoreCreateMutex();
}
void os_app_early_init(void) {
// Initialize display first as that gives us a nice splash screen.
st3m_gfx_init();
// Submit splash a couple of times to make sure we've fully flushed out the
// initial framebuffer (both on-ESP and in-screen) noise before we turn on
// the backlight.
for (int i = 0; i < 4; i++) {
st3m_gfx_splash("st3m loading...");
}
flow3r_bsp_display_set_backlight(100);
st3m_fs_init();
}
void os_app_main(void)
{
locks_init();
ESP_LOGI(TAG, "Starting on %s...", flow3r_bsp_hw_name);
ESP_ERROR_CHECK(i2c_master_init());
ESP_LOGI(TAG, "I2C initialized successfully");
audio_init();
leds_init();
init_buttons();
captouch_init();
spio_badge_link_disable(255);
captouch_force_calibration();
xTaskCreatePinnedToCore(&io_fast_task, "iofast", 4096, NULL, configMAX_PRIORITIES-1, NULL, 0);
xTaskCreatePinnedToCore(&io_slow_task, "ioslow", 4096, NULL, configMAX_PRIORITIES-2, NULL, 0);
hw_init_done = 1;
}
uint8_t hardware_is_initialized(){
return hw_init_done;
}
#ifndef DEF_apa102LEDStrip
#define DEF_apa102LEDStrip
struct apa102LEDStrip
{
unsigned char *LEDs;
short int _frameLength;
short int _endFrameLength;
short int _numLEDs;
unsigned char _bytesPerLED;
short int _counter;
unsigned char _globalBrightness;
};
void initLEDs(struct apa102LEDStrip *ledObject, short int numLEDs, unsigned char bytesPerLED, unsigned char globalBrightness);
void setPixel(struct apa102LEDStrip *ledObject, short int pixelIndex, unsigned char *pixelColour);
void getPixel(struct apa102LEDStrip *ledObject, short int pixelIndex, unsigned char *pixelColour);
#endif
#pragma once
#include <stdint.h>
#define SAMPLE_RATE 16000
/* Initializes I2S bus, the audio task and required data structures.
* Expects an initialized I2C bus, will fail ungracefully otherwise (TODO).
* Requires the I2C lock.
*/
void audio_init();
uint16_t count_audio_sources();
uint16_t add_audio_source(void * render_data, void * render_function);
void remove_audio_source(uint16_t index);
/* Polls hardware to check if headphones, headset or line in are plugged
* into the 3.5mm jacks. If it detects a plug in the headphone jack, speakers
* are automatically muted. There is no override for this at this moment.
*
* Should be called periodically (100ms ish?) by a low priority task. Requires
* the I2C lock.
*/
void audio_update_jacksense(void);
/* Returns 1 if headphones with or without microphone were connected to the
* headphone jack at the last call of audio_update_jacksense.
*/
uint8_t audio_headphones_are_connected();
/* Returns 1 if headphones with microphone were connected to the headphone jack
* at the last call of audio_update_jacksense.
*/
uint8_t audio_headset_is_connected();
/* If a sleeve contact mic doesn't pull the detection pin low enough the
* codec's built in headphone detection might fail. Calling this function
* with 'enable = 1' overrides the detection and assumes there's headphones
* plugged in. Call with 'enable = 0' to revert to automatic detection.
*/
void audio_headphones_detection_override(uint8_t enable);
/* Attempts to set target volume for the headphone output/onboard speakers
* respectively, clamps/rounds if necessary and returns the actual volume.
* Absolute reference arbitrary.
* Does not unmute, use audio_{headphones_/speaker_/}set_mute as needed.
* Enters fake mute if requested volume is below the value set by
* audio_{headphones/speaker}_set_minimum_volume_user.
*
* Note: This function uses a hardware PGA for the coarse value and software
* for the fine value. These two methods are as of yet not synced so that there
* may be a transient volume "hiccup". "p1" badges only use software volume.
* The unspecified variant automatically chooses the adequate channel (**).
*/
float audio_headphones_set_volume_dB(float vol_dB);
float audio_speaker_set_volume_dB(float vol_dB);
float audio_set_volume_dB(float vol_dB);
/* Like the audio_{headphones_/speaker_/}set_volume family but changes relative
* to last volume value.
*/
float audio_headphones_adjust_volume_dB(float vol_dB);
float audio_speaker_adjust_volume_dB(float vol_dB);
float audio_adjust_volume_dB(float vol_dB);
/* Returns volume as set with audio_{headphones/speaker}_set_volume_dB.
* The unspecified variant automatically chooses the adequate channel (**).
*/
float audio_headphones_get_volume_dB();
float audio_speaker_get_volume_dB();
float audio_get_volume_dB();
/* Mutes (mute = 1) or unmutes (mute = 0) the specified channel.
* The unspecified variant automatically chooses the adequate channel (**).
*
* Note: Even if a channel is unmuted it might not play sound depending on
* the return value of audio_headphone_are_connected. There is no override for
* this (see HEADPHONE PORT POLICY below).
*/
void audio_headphones_set_mute(uint8_t mute);
void audio_speaker_set_mute(uint8_t mute);
void audio_set_mute(uint8_t mute);
/* Returns 1 if channel is muted, 0 if channel is unmuted.
* The unspecified variant automatically chooses the adequate channel (**).
*/
uint8_t audio_headphones_get_mute();
uint8_t audio_speaker_get_mute();
uint8_t audio_get_mute();
/* Set the minimum and maximum allowed volume levels for speakers and headphones
* respectively. Clamps with hardware limitations. Maximum clamps below the minimum
* value, minimum clamps above the maximum. Returns clamped value.
*/
float audio_headphones_set_minimum_volume_dB(float vol_dB);
float audio_headphones_set_maximum_volume_dB(float vol_dB);
float audio_speaker_set_minimum_volume_dB(float vol_dB);
float audio_speaker_set_maximum_volume_dB(float vol_dB);
/* Returns the minimum and maximum allowed volume levels for speakers and headphones
* respectively. Change with audio_{headphones/speaker}_set_{minimum/maximum}_volume_dB.
*/
float audio_headphones_get_minimum_volume_dB();
float audio_headphones_get_maximum_volume_dB();
float audio_speaker_get_minimum_volume_dB();
float audio_speaker_get_maximum_volume_dB();
/* Syntactic sugar for drawing UI: Returns channel volume in a 0..1 range,
* scaled into a 0.01..1 range according to the values set with
* audio_{headphones_/speaker_/}set_{maximum/minimum}_volume_ and 0 if in a
* fake mute condition.
*
* The unspecified variant automatically chooses the adequate channel (**).
*/
float audio_headphones_get_volume_relative();
float audio_speaker_get_volume_relative();
float audio_get_volume_relative();
/* (**) if audio_headphones_are_connected returns 1 the "headphone" variant
* is chosen, else the "speaker" variant is chosen.
*/
/*
HEADPHONE PORT POLICY
Under normal circumstances it is an important feature to have a reliable speaker
mute when plugging in headphones. However, since the headphone port on the badge
can also be used for badge link, there are legimate cases where it is desirable to
have the speakers unmuted while a cable is plugged into the jack.
As a person who plugs in the headphones on the tram, doesn't put them on, turns on
music to check if it's not accidentially playing on speakers and then finally puts
on headphones (temporarily, of course, intermittent checks if the speakers didn't
magically turn on are scheduled according to our general anxiety level) we wish to
make it difficult to accidentially have sound coming from the speakers.
Our proposed logic is as follows (excluding boot conditions):
1) Badge link TX cannot be enabled for any of the headphone jack pins without a
cable detected in the jack. This is to protect users from plugging in headphones
while badge link is active and receiving a short but potentially very loud burst
of digital data before the software can react to the state change.
2) If the software detects that the headphone jack has changed from unplugged to
plugged it *always* turns off speakers, no exceptions.
3) If a user wishes to TX on headphone badge link, they must confirm a warning that
having headphones plugged in may potentially cause hearing damage *every time*.
4) If a user wishes to RX or TX on headphone badge link while playing sound on the
onboard speakers, they must confirm a warning *every time*.
We understand that these means seem extreme, but we find them to be a sensible
default configuration to make sure people can safely operate the device without
needing to refer to a manual.
(TX here means any state that is not constantly ~GND with whatever impedance.
While there are current limiting resistors (value TBD at the time of writing, but
presumably 100R-470R) in series with the GPIOs, they still can generate quite some
volume with standard 40Ohm-ish headphones. Ideally the analog switch will never
switch to the GPIOs without a cable plugged in.)
*/
#pragma once
#include <stdint.h>
/* GENERAL INFORMATION
*
* petal index: 0 is the top petal above the USB-C jack, increases ccw so that
* bottom petals are uneven and top petals even.
* TODO: LEDs are indexed differently, this should be harmonized
* in the impending API refactor.
*
* captouch data: full uint16_t range per stage, higher values indicate touch.
* pad index: defined in captouch.c
*
*
* IOU: the internals are still subject to major restructuring and are not
* documented as of yet. will do once the data structures actually make sense
* and are not duct tape upon duct tape.
*/
/* polls data from both captouch chips and processes it, either by updating
* the captouch data exposed to the user or running a calibration cycle.
*
* the captouch chips has updated their registers every 9.2ms, so the fn
* should be called every 10ms or so.
*
* this will be replaced someday by an interrupt event triggered system,
* but this would ideally already implement configuration switching to
* optimize latency by grouping pads and to expose the unused pad which
* is a nontrivial task for another day.
*/
void captouch_read_cycle(void);
/* the captouch chip can generate an "afe" offset in the analog domain before
* the ADC to optimize the readout range. according to the datasheet this should
* be in the middle of the 16bit delta sigma ADC range (without much reasoning
* supplied), however we found that having a higher range is beneficial.
*
* the calibration cycle is optimizing the afe coefficients so that the output of
* the "untouched" pads is close to the target set with this with this function/
*
* default target: 6000, manufacturer recommendation: 32676
*/
void captouch_set_calibration_afe_target(uint16_t target);
/* starts a a calibration cycle which is intended to run when the captouch
* pads are not being touched. the cycle consists of two parts:
*
* 1) optimize the afe coefficients (see captouch_set_calibration_afe_target)
*
* 2) with the new afe coefficients applied, average the readings in the untouched
* state into a software calibration list which is normally subtracted from the
* captouch outputs. this makes up for the limited resolution of the of the afe
* coefficient calibration.
*/
void captouch_force_calibration();
/* indicates if a calibration cycle is currently active. the readings for
* captouch_read_cycle and captouch_get_petal_* during a calibration cycle.
*
* 1: calibration cycle active
* 0: calibration cycle inactive
*/
uint8_t captouch_calibration_active();
/* returns uint16_t which encodes each petal "touched" state as the bit
* corresponding to the petal index. "touched" is determined by checking if
* any of the pads belonging to the petal read a value higher than their
* calibration value plus their threshold (see captouch_set_petal_pad_threshold)
*/
uint16_t read_captouch(void);
/* sets threshold for a petal pad above which read_captouch considers a pad as
* touched.
*
* petal: petal index
* pad: pad index
* thres: threshold value
*/
void captouch_set_petal_pad_threshold(uint8_t petal, uint8_t pad, uint16_t thres);
/* returns last read captouch value from a petal pad without subtracting its
* calibration reference. typically only needed for debugging.
*
* petal: petal index
* pad: pad index
*/
uint16_t captouch_get_petal_pad_raw(uint8_t petal, uint8_t pad);
/* returns calibration reference for a petal pad.
*
* petal: petal index
* pad: pad index
*/
uint16_t captouch_get_petal_pad_calib_ref(uint8_t petal, uint8_t pad);
/* returns calibrated value from petal. clamps below 0.
*
* petal: petal index
* pad: pad index
*/
uint16_t captouch_get_petal_pad(uint8_t petal, uint8_t pad);
/* estimates the azimuthal finger position on a petal in arbitrary units.
* returns 0 if hardware doesn't support this.
*
* petal: petal index
* pad: pad index
*/
int32_t captouch_get_petal_phi(uint8_t petal);
/* estimates the radial finger position on a petal in arbitrary units.
* returns 0 if hardware doesn't support this.
*
* petal: petal index
* pad: pad index
*/
int32_t captouch_get_petal_rad(uint8_t petal);
/* configures the captouch chips, prefills internal structs etc.
*/
void captouch_init(void);
/* TODO: didn't look into what it does, never used it, just copied it from
* the hardware verification firmware along with the rest. didn't break it
* _intentionally_ but never tested it either.
*/
void captouch_print_debug_info(void);
/*
This example code is in the Public Domain (or CC0 licensed, at your option.)
Unless required by applicable law or agreed to in writing, this
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied.
*/
#pragma once
#include <stdint.h>
#include "esp_err.h"
#define IMAGE_W 240
#define IMAGE_H 240
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Decode the jpeg ``image.jpg`` embedded into the program file into pixel data.
*
* @param pixels A pointer to a pointer for an array of rows, which themselves are an array of pixels.
* Effectively, you can get the pixel data by doing ``decode_image(&myPixels); pixelval=myPixels[ypos][xpos];``
* @return - ESP_ERR_NOT_SUPPORTED if image is malformed or a progressive jpeg file
* - ESP_ERR_NO_MEM if out of memory
* - ESP_OK on succesful decode
*/
esp_err_t decode_image(uint16_t **pixels);
#ifdef __cplusplus
}
#endif
#pragma once
#include <stdint.h>
void os_app_early_init(void);
void os_app_main(void);
uint8_t hardware_is_initialized(void);
#pragma once
#include <stdint.h>
#include <stdbool.h>
/* inits stuff ig
*/
void leds_init();
/* Set a single/all LEDs to change color with the next (auto) update. Index starts above
* USB-C port and increments ccw. There are 8 LEDs per top petal.
*/
void leds_set_single_rgb(uint8_t index, uint8_t red, uint8_t green, uint8_t blue);
void leds_set_single_hsv(uint8_t index, float hue, float sat, float value);
void leds_set_all_rgb(uint8_t red, uint8_t green, uint8_t blue);
void leds_set_all_hsv(float hue, float sat, float value);
/* Set/get global LED brightness. Default 69.
*/
void leds_set_brightness(uint8_t brightness);
uint8_t leds_get_brightness();
/* Set/get maximum change rate of brightness. Set to 1-3 for fade effects, set to
* 255 to disable. Currently clocks at 10Hz.
*/
void leds_set_slew_rate(uint8_t slew_rate);
uint8_t leds_get_slew_rate();
/* Update LEDs.
*/
void leds_update();
/* Used internally for slew rate animation loop.
*/
void leds_update_hardware();
/* Bend the rgb curves with an exponent each. (1,1,1) is default, (2,2,2) works well too
* If someone wants to do color calibration, this is ur friend
*/
void leds_set_gamma(float red, float green, float blue);
/* leds_update is periodically called by the background task for slew rate animation when
* set to 1. This adds user changes immediately. Useful with low slew rates.
*/
void leds_set_auto_update(bool on);
bool leds_get_auto_update();
#pragma once
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
SemaphoreHandle_t mutex_i2c;
SemaphoreHandle_t mutex_LED;
#pragma once
#include <stdint.h>
#define BUTTON_PRESSED_DOWN 2
#define BUTTON_PRESSED_LEFT -1
#define BUTTON_PRESSED_RIGHT 1
#define BUTTON_NOT_PRESSED 0
#define BADGE_LINK_PIN_MASK_LINE_IN_TIP 0b0001
#define BADGE_LINK_PIN_MASK_LINE_IN_RING 0b0010
#define BADGE_LINK_PIN_MASK_LINE_OUT_TIP 0b0100
#define BADGE_LINK_PIN_MASK_LINE_OUT_RING 0b1000
#define BADGE_LINK_PIN_MASK_LINE_IN ((BADGE_LINK_PIN_MASK_LINE_IN_TIP) | (BADGE_LINK_PIN_MASK_LINE_IN_RING))
#define BADGE_LINK_PIN_MASK_LINE_OUT ((BADGE_LINK_PIN_MASK_LINE_OUT_TIP) | (BADGE_LINK_PIN_MASK_LINE_OUT_RING))
#define BADGE_LINK_PIN_MASK_ALL ((BADGE_LINK_PIN_MASK_LINE_IN) | (BADGE_LINK_PIN_MASK_LINE_OUT))
#define BADGE_LINK_PIN_INDEX_LINE_IN_TIP 4
#define BADGE_LINK_PIN_INDEX_LINE_IN_RING 5
#if defined(CONFIG_BADGE23_HW_GEN_P6)
#define BADGE_LINK_PIN_INDEX_LINE_OUT_TIP 7
#define BADGE_LINK_PIN_INDEX_LINE_OUT_RING 6
#else
#define BADGE_LINK_PIN_INDEX_LINE_OUT_TIP 6
#define BADGE_LINK_PIN_INDEX_LINE_OUT_RING 7
#endif
/* Initializes GPIO modes, prefills structs, etc. Call before using library.
*/
void init_buttons();
/* Gets data from I2C portexpanders and GPIOs. Requires I2C lock.
*/
void update_button_state();
/* UI sugar: People might prefer using one button for in-application stuff and the other
* for entering main menu/volume control, depending on their handedness and how they hold
* the badge. This function allows them configure this and is meant to be only be used by
* the OS user config handler.
*
* Set to 1 to use the left shoulder button as the menu button, 0 for the right
*/
void spio_menu_button_set_left(bool left);
/* Gets user menu button user preference as set with spio_menu_button_set_left.
*/
int8_t spio_menu_button_get_left();
/* Read the state of the menu/application button at the last call of update_button_state.
* Compare with BUTTON_(NOT)PRESSED* constants for -h.
*/
int8_t spio_menu_button_get();
int8_t spio_application_button_get();
/* Read the state of the left/right button at the last call of update_button_state.
* Compare with BUTTON_(NOT)PRESSED* constants for -h.
* This ignores user preference and should be used only with good reason.
*/
int8_t spio_left_button_get();
int8_t spio_right_button_get();
/* Gets active badge links ports. Mask with BADGE_LINK_PIN_MASK_LINE_{IN/OUT}_{TIP/RING}. The corresponding
* GPIO indices are listed in BADGE_LINK_PIN_INDEX_LINE_{OUT/IN}_{TIP/RING}.
*/
uint8_t spio_badge_link_get_active(uint8_t pin_mask);
/* Disables badge link ports. Mask with BADGE_LINK_PIN_MASK_LINE_{IN/OUT}_{TIP/RING}. The corresponding
* GPIO indices are listed in BADGE_LINK_PIN_INDEX_LINE_{OUT/IN}_{TIP/RING}.
* Returns the output of spio_badge_link_get_active after execution.
*/
uint8_t spio_badge_link_disable(uint8_t pin_mask);
/* Enables badge link ports. Mask with BADGE_LINK_PIN_MASK_LINE_{IN/OUT}_{TIP/RING}. The corresponding
* GPIO indices are listed in BADGE_LINK_PIN_INDEX_LINE_{OUT/IN}_{TIP/RING}_PIN.
* Returns the output of spio_badge_link_get_active after execution.
*
* Do NOT connect headphones to a badge link port. You might hear a ringing for a while. Warn user.
*/
uint8_t spio_badge_link_enable(uint8_t pin_mask);
#pragma once
#include <stdint.h>
#include <stdio.h>
#define TRAD_OSC_DECAY_STEP 0.01
#define TRAD_OSC_ATTACK_STEP 0.01
#define TRAD_OSC_MIN_ATTACK_ENV 0.01
#define TRAD_OSC_ATTACK_POP_BLOCK 16
typedef struct {
//user variables
float freq; //in hertz, negative frequencies for linFM allowed
float bend;
float vol; //output volume
float env;
uint8_t env_phase; //0: off, 1: attack, 2: hold, 3: decay
uint8_t skip_hold;
float gate; //below what volume the oscillator stops and returns 0
uint16_t decay_steps; //after how many sample rate steps the volume reduces
//by factor TRAD_OSC_DECAY_STEP, set 0 for no decay
uint16_t attack_steps;
uint8_t waveform; //0: sine, 1: fast sine, 2: tri, 3: saw,
//4: square, 5: 33% pulse, 6: 25% pulse
//internal data storage, not for user access
float counter; //state of central sawtooth oscillator, [-1..1] typ.
uint16_t env_counter;
int8_t overflow_event; //set to -1 when counter underflows (below -1),
//set to +1 when counter overflows (above 1)
//not reset or used by anything so far
uint16_t noise_reg;
} trad_osc_t;
//#define KS_BUFFER_SIZE (SAMPLE_RATE)/20
#define KS_BUFFER_SIZE 800
typedef struct {
//user variables
float freq; //frequency in hertz, negative frequencies are rectified,
//minimum freq determined by KS_BUFFER_SIZE
float feedback; //feedback value, will be compensated with frequency
//for equal decay across spectrum, [-1..1] without
//internal data storage, not for user access
float tape[KS_BUFFER_SIZE]; //the delay chain
float real_feedback; //compensated feedback value
} ks_osc_t; //karplus strong
float run_trad_osc(trad_osc_t * osc);
void trad_osc_set_freq_semitone(trad_osc_t * osc, float bend);
void trad_osc_set_freq_Hz(trad_osc_t * osc, float freq);
void trad_osc_set_waveform(trad_osc_t * osc, uint8_t waveform);
void trad_osc_set_attack(trad_osc_t * osc, uint16_t attack);
void trad_osc_set_decay(trad_osc_t * osc, uint16_t decay);
void trad_env_stop(trad_osc_t * osc);
void trad_env_fullstop(trad_osc_t * osc);
void trad_env_start(trad_osc_t * osc);
void render_audio(
instrument_descriptor_t instrument_descriptor,
instrument_t instance,
unsigned int sample_count,
float * output_vector
){
for(unsigned int i = 0; i < sample_count; i++){
instrument_descriptor->render_audio_sample(instance, sample_count, output_vector[2*i]);
}
}
void render_audio_adding(
instrument_descriptor_t instrument_descriptor,
instrument_t instance,
unsigned int sample_count,
float * output_vector,
float gain
){
if(gain <= 0.0000001) return;
float temp[2];
for(unsigned int i = 0; i < sample_count; i++){
instrument_descriptor->render_audio_sample(instance, sample_count, temp);
output_vector[2*i] += gain * buffer[0];
output_vector[2*i+1] += gain * buffer[1];
}
}
void append_instrument_descriptor(
instrument_descriptor_list_t * list,
void * construct_instrument_descriptor
){
lle_t * element = list;
while(element->next != NULL){
element = element->next;
}
element->next = malloc(sizeof(lle_t);
if(element->next == NULL) return;
element = element->next;
element->next = NULL;
element->content = construct_instrument_descriptor();
}
instrument_descriptor_list_t * list_builtin_instrument_descriptors(){
//really hope we can make this more elegant some day
instrument_descriptor_list_t * list = NULL;
//add your instrument here!
append_instrument_descriptor(list, &minimal_example_descriptor);
return list;
}
void instantiate_instrument(active_instrument_list_t instruments,
instrument_descriptor_t descriptor
){
descriptor->new_instrument
}
void mix_instruments_audio(active_instrument_list_t instruments,
unsigned int sample_count,
float * output_vector
){
active_instrument_t instrument = instruments;
while(instrument->next != NULL){
render_audio_adding(instrument->descriptor,
instrument->instrument,
sample_count,
output_vector,
instrument->gain)
instrument = instrument->next;
}
}
/* wip instrument api for badge23 (in large parts inspired by ladspa)
current status: none of this is hooked up or functional or compiles, just drafting things rn
some core concepts:
- several instruments can run at the same time (e.g., drum computer running in background),
with only one of them being in foreground and using buttons and display
- instruments are as "self contained" as possible, i.e. they access buttons and display with
minimal host involvement and pretty much just produce audio "on their own". aside from
scheduling the host mostly does some cap touch preprocessing and the audio output mixdown
- different timing requirements -> different "threads" for audio, buttons, display each
(leds: special case, see below)
open questions:
- led animations: instruments should be able to output led patterns. maybe keeping a dummy
led array in ram for each running instrument and allowing users to create and run "shaders"
would be a desirable functional mode; do we want this/does this need any extra api?
- for performance reasons: instruments are expected to behave themselves, i.e. not access hw
without permission or write to read-only locations, can we do better than that without
excessive overhead? and if we can, do we _want_ to? (devices that make electronic musical
instruments malfunction on purpose are not uncommon in general)
- badge link/cv data input/output: can probably be added to the descriptor easily? shouldn't
freeze api before tho
*/
//===========================================================================================
//some hardware dummy definitions, move somewhere else someday maybe
typedef struct {
int intensity; //touch strength, considered as no touch if below 0
int rad; //radial position
int az; //cw azimuthal position (only meaningful for top petals);
} petal_t;
typedef int button_t; //0: no press, -1: left, 1: right, 2: down
typedef struct { //read-only (shared between all instruments, unprotected)
petal_t petals[10]; //even: top, odd: bottom, 0 at usb-c jack, count ccw
button_t button; //can be either left or right, depending on host
//handedness settings. the other button is reserved for
//host use and is not exposed here.
} hardware_inputs_t;
//===========================================================================================
typedef void * instrument_t; //contains instrument instance data, not to be interpreted by host
typedef struct _instrument_descriptor_t {
unsigned int unique_id;
//null terminated instrument name
const char * name;
//allocates memory for new instance data and returns pointer to it (mandatory)
instrument_t (* new_instrument)(const struct _instrument_descriptor * descriptor,
unsigned int sample_rate,
hardware_inputs_t * hw);
//frees instance data memory (mandatory)
void (* delete_instrument) (instrument_t instance);
//renders a single stereo audio sample (optional, NULL if not supported)
void (* render_audio_sample) (instrument_t instance);
//handles petal/button/sensor input, ideally runs every 3-8ms (optional, NULL if not supported)
void (* process_user_input) (instrument_t instance);
//only runs when instrument is in foreground (optional, NULL if not supported)
void (* update_display) (instrument_t instance);
//(optional, NULL if not supported)
void (* update_leds) (instrument_t instance);
} instrument_descriptor_t;
// this function is called once per instrument type before use (i.e. around boot) and returns a
// filled out instrument descriptor struct to be used by the host for creating instrument instances
// returns null if allocation fails
const instrument_descriptor_t * contruct_instrument_descriptor();
//===========================================================================================
//host-side helper functions
void render_audio(
instrument_descriptor_t instrument_descriptor,
instrument_t instance,
unsigned int sample_count,
float * output_vector
);
void render_audio_adding(
instrument_descriptor_t instrument_descriptor,
instrument_t instance,
unsigned int sample_count,
float * output_vector,
float gain
);
typedef struct {
void * content;
lle_t * next;
} lle_t; //linked list element
typedef lle_t instrument_descriptor_list_t;
typedef struct {
instrument_t * instrument;
instrument_descriptor_t descriptor;
char is_foreground;
char is_rendering_leds;
float gain;
} active_instrument_t;
void append_instrument_descriptor(
instrument_descriptor_list_t * list,
void * construct_instrument_descriptor
);
instrument_descriptor_list_t * list_builtin_instrument_descriptors();
typedef lle_t active_instrument_list_t;
void mix_instruments_audio(active_instrument_list_t instruments,
unsigned int sample_count,
float * output_vector
);
//===========================================================================================
//simple instrument example implementation
//trad_osc is made up rn, didn't check how the existing implementation works
typedef struct{
unsigned int * sample_rate;
hardware_inputs_t * hw;
trad_osc_t[30] osc;
unsigned int sample_rate;
hardware_inputs_t * hw;
float last_freq; //frequency of last note played to write to display
} minimal_example_t;
void minimal_example_render_sample(instrument_handle inst, float * stereo_output){
float acc = 0;
for(int i = 0; i < 30; i++){
acc += trad_osc_run(&inst.osc[i], inst.sample_rate);
}
stereo_output[0] = acc; // both channels the same -> mono
stereo_output[1] = acc;
}
void minimal_example_process_user_input(instrument_handle inst){
static int petal_prev[10];
for(int i = 0; i < 10; i++){
if(inst->hw.petals[i].intensity > 0){ //if the pad is touched...
if(!petal_prev[i]){ //and it's a new touch...
if(button != 2){ //if button isn't pressed: play single note in different octaves
int j = i + (inst->hw.button + 1) * 10; //choose osc
trad_osc_start(&inst.osc[j]); //play a tone
inst->last_freq = inst.osc[j].freq;
} else { //for button center: all the octaves at once
trad_osc_start(&inst.osc[i]); //play a tone
trad_osc_start(&inst.osc[i+10]); //play a tone
trad_osc_start(&inst.osc[i+20]); //play a tone
inst->last_freq = inst.osc[i+10].freq;
}
}
petal_prev[i] = 1;
} else {
petal_prev[i] = 0;
}
}
}
void minimal_example_update_display(instrument_handle inst){
display_print("%f", inst->last_freq);
}
static float pad_to_freq(int pad){
int j = pad % 10;
if(j) j++; //skip min 2nd
if(j>8) j++; //skip maj 6th
j += (pad/10) * 12; //add octaves
float freq = 440 * pow(2., j/12.);
}
instrument_t new_minimal_example(
const struct _instrument_descriptor * descriptor,
unsigned int sample_rate,
hardware_inputs_t * hw)
{
instrument_t inst = malloc(sizeof(minimal_example_t));
if(inst == NULL) return NULL;
inst->sample_rate = sample_rate;
inst->hw = hw;
for(int i = 0; i < 30; i++){
inst->osc[i] = trad_osc_new(pad_to_freq(i), sample_rate);
//other osc parameters (wave, envelope, etc.) omitted for clarity
}
return inst;
}
void delete_minimal_example(instrument_t inst){
free(inst);
}
const instrument_descriptor_t * minimal_example_descriptor(){
instrument_descriptor_t * inst = malloc(sizeof(instrument_descriptor_t));
if(inst == NULL) return NULL;
inst->unique_id = 0;
inst->name = "simple instrument";
inst->render_audio_sample = &minimal_example_render_sample;
inst->new_instrument = &new_minimal_example;
inst->delete_instrument = &delete_minimal_example;
inst->update_display = NULL;
inst->process_user_input = minimal_example_user_input;
inst->update_leds = NULL;
}
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/queue.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "esp_system.h"
#include "badge23/leds.h"
#include "badge23/lock.h"
static uint8_t leds_brightness = 69;;
static uint8_t leds_slew_rate = 255;
static bool leds_auto_update = 0;
static uint8_t gamma_red[256];
static uint8_t gamma_green[256];
static uint8_t gamma_blue[256];
#if defined(CONFIG_BADGE23_HW_GEN_P1)
#define LED_SPI_PORT
#elif defined(CONFIG_BADGE23_HW_GEN_P3) || defined(CONFIG_BADGE23_HW_GEN_P4) || defined(CONFIG_BADGE23_HW_GEN_P6)
#define LED_ASYNC_PORT
#else
#error "leds not implemented for this badge generation"
#endif
typedef struct leds_cfg {
int leaf;
size_t size;
size_t position;
size_t slot;
int timer;
} leds_cfg_t;
static leds_cfg_t active_leds[11];
struct RGB
{
unsigned char R;
unsigned char G;
unsigned char B;
};
struct RGB led_target[40] = {0,};
struct RGB led_target_buffer[40] = {0,};
struct RGB led_hardware_value[40] = {0,};
struct HSV
{
double H;
double S;
double V;
};
struct RGB HSVToRGB(struct HSV hsv) {
double r = 0, g = 0, b = 0;
if (hsv.S == 0)
{
r = hsv.V;
g = hsv.V;
b = hsv.V;
}
else
{
int i;
double f, p, q, t;
if (hsv.H == 360)
hsv.H = 0;
else
hsv.H = hsv.H / 60;
i = (int)trunc(hsv.H);
f = hsv.H - i;
p = hsv.V * (1.0 - hsv.S);
q = hsv.V * (1.0 - (hsv.S * f));
t = hsv.V * (1.0 - (hsv.S * (1.0 - f)));
switch (i)
{
case 0:
r = hsv.V;
g = t;
b = p;
break;
case 1:
r = q;
g = hsv.V;
b = p;
break;
case 2:
r = p;
g = hsv.V;
b = t;
break;
case 3:
r = p;
g = q;
b = hsv.V;
break;
case 4:
r = t;
g = p;
b = hsv.V;
break;
default:
r = hsv.V;
g = p;
b = q;
break;
}
}
struct RGB rgb;
rgb.R = r * 255;
rgb.G = g * 255;
rgb.B = b * 255;
return rgb;
}
#ifdef LED_SPI_PORT
#include "driver/spi_master.h"
#include "badge23/apa102LEDStrip.h"
#define totalPixels 40
#define bytesPerPixel 4
static struct apa102LEDStrip leds;
static spi_device_handle_t spi_led;
static spi_transaction_t spiTransObject;
static esp_err_t ret;
static spi_bus_config_t buscfg;
static spi_device_interface_config_t devcfg;
#define maxSPIFrameInBytes 8000
#define maxSPIFrequency 10000000
void renderLEDs()
{
spi_device_queue_trans(spi_led, &spiTransObject, portMAX_DELAY);
}
static int setupSPI()
{
//Set up the Bus Config struct
buscfg.miso_io_num=-1;
buscfg.mosi_io_num=18;
buscfg.sclk_io_num=8;
buscfg.quadwp_io_num=-1;
buscfg.quadhd_io_num=-1;
buscfg.max_transfer_sz=maxSPIFrameInBytes;
//Set up the SPI Device Configuration Struct
devcfg.clock_speed_hz=maxSPIFrequency;
devcfg.mode=0;
devcfg.spics_io_num=-1;
devcfg.queue_size=1;
//Initialize the SPI driver
ret=spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO);
ESP_ERROR_CHECK(ret);
//Add SPI port to bus
ret=spi_bus_add_device(SPI2_HOST, &devcfg, &spi_led);
ESP_ERROR_CHECK(ret);
return ret;
}
static void set_single_led(uint8_t index, uint8_t c[3]){
setPixel(&leds, index, c);
}
static void _leds_init() {
memset(active_leds, 0 , sizeof(active_leds));
setupSPI();
initLEDs(&leds, totalPixels, bytesPerPixel, 255);
//Set up SPI tx/rx storage Object
memset(&spiTransObject, 0, sizeof(spiTransObject));
spiTransObject.length = leds._frameLength*8;
spiTransObject.tx_buffer = leds.LEDs;
//TaskHandle_t handle;
//xTaskCreate(&leds_task, "LEDs player", 4096, NULL, configMAX_PRIORITIES - 2, &handle);
}
#endif
#ifdef LED_ASYNC_PORT
#include "../../espressif__led_strip/include/led_strip.h"
led_strip_t *led_strip_init(uint8_t channel, uint8_t gpio, uint16_t led_num);
#define LED_GPIO_NUM 14
#define LED_RMT_CHAN 0
led_strip_t * led_strip;
static void _leds_init(){
memset(active_leds, 0 , sizeof(active_leds));
led_strip = led_strip_init(LED_RMT_CHAN, LED_GPIO_NUM, 40);
}
void set_single_led(uint8_t index, uint8_t c[3]){
index = ((39-index) + 1 + 32)%40;
led_strip->set_pixel(led_strip, index, c[0], c[1], c[2]);
}
static void renderLEDs(){
led_strip->refresh(led_strip, 1000);
}
#endif
uint8_t led_get_slew(int16_t old, int16_t new, int16_t slew){
if(new > old + slew){
return old + slew;
} else if(new > old) {
return new;
}
if(new < old - slew){
return old - slew;
} else if(new < old) {
return new;
}
return old;
}
static void leds_update_target(){
for(int i = 0; i < 40; i++){
led_target[i].R = led_target_buffer[i].R;
led_target[i].G = led_target_buffer[i].G;
led_target[i].B = led_target_buffer[i].B;
}
}
void leds_update_hardware(){
if(leds_auto_update) leds_update_target();
xSemaphoreTake(mutex_LED, portMAX_DELAY);
for(int i = 0; i < 40; i++){
uint8_t c[3];
c[0] = led_target[i].R * leds_brightness/255;
c[1] = led_target[i].G * leds_brightness/255;
c[2] = led_target[i].B * leds_brightness/255;
c[0] = gamma_red[c[0]];
c[1] = gamma_green[c[1]];
c[2] = gamma_blue[c[2]];
c[0] = led_get_slew(led_hardware_value[i].R, c[0], leds_slew_rate);
c[1] = led_get_slew(led_hardware_value[i].G, c[1], leds_slew_rate);
c[2] = led_get_slew(led_hardware_value[i].B, c[2], leds_slew_rate);
led_hardware_value[i].R = c[0];
led_hardware_value[i].G = c[1];
led_hardware_value[i].B = c[2];
int8_t index = i + 3 % 40;
set_single_led(index, c);
}
renderLEDs();
xSemaphoreGive(mutex_LED);
}
void leds_set_single_rgb(uint8_t index, uint8_t red, uint8_t green, uint8_t blue){
led_target_buffer[index].R = red;
led_target_buffer[index].G = green;
led_target_buffer[index].B = blue;
}
void leds_set_single_hsv(uint8_t index, float hue, float sat, float val){
struct RGB rgb;
struct HSV hsv;
hsv.H = hue;
hsv.S = sat;
hsv.V = val;
rgb = HSVToRGB(hsv);
led_target_buffer[index].R = rgb.R;
led_target_buffer[index].G = rgb.G;
led_target_buffer[index].B = rgb.B;
}
void leds_set_all_rgb(uint8_t red, uint8_t green, uint8_t blue){
for(int i = 0; i<40; i++){
leds_set_single_rgb(i, red, green, blue);
}
}
void leds_set_all_hsv(float h, float s, float v){
for(int i = 0; i<40; i++){
leds_set_single_hsv(i, h, s, v);
}
}
void leds_update(){
leds_update_target();
leds_update_hardware();
}
void leds_init(){
for(uint16_t i = 0; i<256; i++){
gamma_red[i] = i;
gamma_green[i] = i;
gamma_blue[i] = i;
}
_leds_init();
}
void leds_set_brightness(uint8_t b){
leds_brightness = b;
}
uint8_t leds_get_brightness(){
return leds_brightness;
}
void leds_set_slew_rate(uint8_t s){
leds_slew_rate = s;
}
uint8_t leds_get_slew_rate(){
return leds_slew_rate;
}
void leds_set_auto_update(bool on){
leds_auto_update = on;
}
bool leds_get_auto_update(){
return leds_auto_update;
}
void leds_set_gamma(float red, float green, float blue){
for(uint16_t i = 0; i<256; i++){
if(i == 0){
gamma_red[i] = 0;
gamma_green[i] = 0;
gamma_blue[i] = 0;
}
float step = ((float) i) / 255.;
gamma_red[i] = (uint8_t) (254.*(pow(step, red))+1);
gamma_green[i] = (uint8_t) (254.*(pow(step, green))+1);
gamma_blue[i] = (uint8_t) (254.*(pow(step, blue))+1);
}
}
//special purpose input outputs
#include "driver/gpio.h"
#include "stdint.h"
#include "badge23/spio.h"
#include "badge23/lock.h"
#include "badge23/audio.h"
#include "driver/i2c.h"
#define I2C_MASTER_NUM 0
#define TIMEOUT_MS 1000
#if defined(CONFIG_BADGE23_HW_GEN_P1)
#define BADGE_LINK_LINE_OUT_TIP_ENABLE_PIN 5
#define BADGE_LINK_LINE_OUT_RING_ENABLE_PIN 6
#define BADGE_LINK_LINE_IN_TIP_ENABLE_PIN 3
#define BADGE_LINK_LINE_IN_RING_ENABLE_PIN 4
#elif defined(CONFIG_BADGE23_HW_GEN_P4) || defined(CONFIG_BADGE23_HW_GEN_P3)
#define BADGE_LINK_LINE_OUT_TIP_ENABLE_PIN 6
#define BADGE_LINK_LINE_OUT_RING_ENABLE_PIN 7
#define BADGE_LINK_LINE_IN_TIP_ENABLE_PIN 5
#define BADGE_LINK_LINE_IN_RING_ENABLE_PIN 4
//on ESP32
#define LEFT_BUTTON_LEFT 3
#define LEFT_BUTTON_MID 0
//on PORTEXPANDER
#define LEFT_BUTTON_RIGHT (0+8)
#define RIGHT_BUTTON_LEFT (6+8)
#define RIGHT_BUTTON_MID (5+8)
#define RIGHT_BUTTON_RIGHT (7+8)
#elif defined(CONFIG_BADGE23_HW_GEN_P6)
#define BADGE_LINK_LINE_OUT_RING_ENABLE_PIN 5
#define BADGE_LINK_LINE_OUT_TIP_ENABLE_PIN 6
#define BADGE_LINK_LINE_IN_TIP_ENABLE_PIN 4
#define BADGE_LINK_LINE_IN_RING_ENABLE_PIN 3
#define ENABLE_INVERTED
//on ESP32
#define RIGHT_BUTTON_MID 3
#define LEFT_BUTTON_MID 0
//on PORTEXPANDER
#define LEFT_BUTTON_RIGHT (0+8)
#define RIGHT_BUTTON_LEFT (4+8)
#define LEFT_BUTTON_LEFT (7+8)
#define RIGHT_BUTTON_RIGHT (5+8)
#endif
static int8_t leftbutton = 0;
static int8_t rightbutton = 0;
static bool menu_button_left = 0;
static uint8_t badge_link_enabled = 0;
/* The MAX7321 doesn't have any input/output pin configuration methods. Instead,
* it has a ~40k pullup resistor to VCC and a programmable shunt transistor to VEE.
* Writing a byte to the IC closes each shunt with a LO at its index.
* Reading a byte returns the state of each pin.
*
* This means that changing a single output bit cannot be changed without some
* information about the other pins. Also a output pin set to HI can read as LO
* if there's an outside shunt.
*/
typedef struct{
uint8_t address;
uint8_t is_output_pin; // mask for pins we wish to use as outputs
uint8_t read_state; //
uint8_t output_state; // goal output state
} max7321_t;
max7321_t port_expanders[2];
void _max7321_update(max7321_t *max){
uint8_t rx = 0;
uint8_t tx = (~(max->is_output_pin)) | max->output_state;
xSemaphoreTake(mutex_i2c, portMAX_DELAY);
esp_err_t tx_error = i2c_master_write_to_device(I2C_MASTER_NUM, max->address, &tx, sizeof(tx), TIMEOUT_MS / portTICK_PERIOD_MS);
esp_err_t rx_error = i2c_master_read_from_device(I2C_MASTER_NUM, max->address, &rx, sizeof(rx), TIMEOUT_MS / portTICK_PERIOD_MS);
xSemaphoreGive(mutex_i2c);
max->read_state = rx;
}
void max7321s_update(){
_max7321_update(&port_expanders[0]);
_max7321_update(&port_expanders[1]);
}
bool max7321s_get_pin(uint8_t pin){
if(pin>15) return 0;
max7321_t * pe = &port_expanders[0];
if(pin>7){
pe = &port_expanders[1];
pin -= 8;
}
return ((pe->read_state) >> pin) & 1;
}
bool max7321s_set_pin(uint8_t pin, bool on){
if(pin>15) return 0;
max7321_t * pe = &port_expanders[0];
if(pin>7){
pe = &port_expanders[1];
pin -= 8;
}
if(((pe->is_output_pin) >> pin) & 1){
if(on){
pe->output_state |= 1<<pin;
} else {
pe->output_state &= ~(1<<pin);
}
return 1;
} else {
return 0;
}
}
void max7321s_set_pinmode_output(uint8_t pin, bool output){
if(pin>15) return 0;
max7321_t * pe = &port_expanders[0];
if(pin>7){
pe = &port_expanders[1];
pin -= 8;
}
if(output){
pe->is_output_pin |= (1<<pin);
} else {
pe->is_output_pin &= ~(1<<pin);
}
}
#if defined(CONFIG_BADGE23_HW_GEN_P1)
#define RIGHT_BUTTON_LEFT 37
#define RIGHT_BUTTON_MID 0
#define RIGHT_BUTTON_RIGHT 35
#define LEFT_BUTTON_LEFT 7
#define LEFT_BUTTON_MID 6
#define LEFT_BUTTON_RIGHT 5
static void _init_buttons(){
//configure all buttons as pullup
uint64_t mask = 0;
mask |= (1ULL << RIGHT_BUTTON_LEFT);
mask |= (1ULL << RIGHT_BUTTON_RIGHT);
mask |= (1ULL << LEFT_BUTTON_LEFT);
mask |= (1ULL << LEFT_BUTTON_MID);
mask |= (1ULL << LEFT_BUTTON_RIGHT);
gpio_config_t cfg = {
.pin_bit_mask = mask,
.mode = GPIO_MODE_INPUT,
.pull_up_en = GPIO_PULLUP_ENABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE
};
ESP_ERROR_CHECK(gpio_config(&cfg));
cfg.pin_bit_mask = 1;
cfg.pull_up_en = GPIO_PULLUP_DISABLE;
ESP_ERROR_CHECK(gpio_config(&cfg));
}
void update_button_state(){
if(!gpio_get_level(RIGHT_BUTTON_LEFT)){
rightbutton = BUTTON_PRESSED_LEFT;
} else if(!gpio_get_level(RIGHT_BUTTON_MID)){
rightbutton = BUTTON_PRESSED_DOWN;
} else if(!gpio_get_level(RIGHT_BUTTON_RIGHT)){
rightbutton = BUTTON_PRESSED_RIGHT;
} else {
rightbutton = BUTTON_NOT_PRESSED;
}
if(!gpio_get_level(LEFT_BUTTON_LEFT)){
leftbutton = BUTTON_PRESSED_LEFT;
} else if(!gpio_get_level(LEFT_BUTTON_MID)){
leftbutton = BUTTON_PRESSED_DOWN;
} else if(!gpio_get_level(LEFT_BUTTON_RIGHT)){
leftbutton = BUTTON_PRESSED_RIGHT;
} else {
leftbutton = BUTTON_NOT_PRESSED;
}
}
#elif defined(CONFIG_BADGE23_HW_GEN_P3) || defined(CONFIG_BADGE23_HW_GEN_P4)
max7321_t port_expanders[] = { {0b01101110, 0, 255, 255},
{0b01101101, 0, 255, 255} };
static void _init_buttons(){
//configure all buttons as pullup
gpio_config_t cfg = {
.pin_bit_mask = 1 << LEFT_BUTTON_LEFT,
.mode = GPIO_MODE_INPUT,
.pull_up_en = GPIO_PULLUP_ENABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE
};
ESP_ERROR_CHECK(gpio_config(&cfg));
cfg.pin_bit_mask = 1;
cfg.pull_up_en = GPIO_PULLUP_DISABLE;
ESP_ERROR_CHECK(gpio_config(&cfg));
max7321s_set_pinmode_output(RIGHT_BUTTON_RIGHT, 0);
max7321s_set_pinmode_output(RIGHT_BUTTON_MID, 0);
max7321s_set_pinmode_output(RIGHT_BUTTON_LEFT, 0);
max7321s_set_pinmode_output(LEFT_BUTTON_RIGHT, 0);
}
int8_t process_button_state(bool r, bool m, bool l){
if(!l){
return BUTTON_PRESSED_LEFT;
} else if(!m){
return BUTTON_PRESSED_DOWN;
} else if(!r){
return BUTTON_PRESSED_RIGHT;
} else {
return BUTTON_NOT_PRESSED;
}
}
void update_button_state(){
max7321s_update();
uint8_t rr = max7321s_get_pin(RIGHT_BUTTON_RIGHT);
uint8_t rm = max7321s_get_pin(RIGHT_BUTTON_MID);
uint8_t rl = max7321s_get_pin(RIGHT_BUTTON_LEFT);
uint8_t lr = max7321s_get_pin(LEFT_BUTTON_RIGHT);
uint8_t ll = gpio_get_level(LEFT_BUTTON_LEFT);
uint8_t lm = gpio_get_level(LEFT_BUTTON_MID);
int8_t new_rightbutton = process_button_state(rr, rm, rl);
int8_t new_leftbutton = process_button_state(lr, lm, ll);
if(new_rightbutton != rightbutton){
//TODO: CALLBACK button_state_has_changed_to(new_rightbutton)
//note: consider menubutton/application button config option
}
if(new_leftbutton != leftbutton){
//TODO: CALLBACK button_state_has_changed_to(new_leftbutton)
}
rightbutton = new_rightbutton;
leftbutton = new_leftbutton;
}
#elif defined(CONFIG_BADGE23_HW_GEN_P6)
max7321_t port_expanders[] = { {0b01101110, 0, 255, 255},
{0b01101101, 0, 255, 255} };
static void _init_buttons(){
//configure all buttons as pullup
gpio_config_t cfg = {
.pin_bit_mask = 1 << RIGHT_BUTTON_MID,
.mode = GPIO_MODE_INPUT,
.pull_up_en = GPIO_PULLUP_ENABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE
};
ESP_ERROR_CHECK(gpio_config(&cfg));
cfg.pin_bit_mask = 1;
cfg.pull_up_en = GPIO_PULLUP_DISABLE;
ESP_ERROR_CHECK(gpio_config(&cfg));
max7321s_set_pinmode_output(RIGHT_BUTTON_RIGHT, 0);
max7321s_set_pinmode_output(LEFT_BUTTON_LEFT, 0);
max7321s_set_pinmode_output(RIGHT_BUTTON_LEFT, 0);
max7321s_set_pinmode_output(LEFT_BUTTON_RIGHT, 0);
}
int8_t process_button_state(bool r, bool m, bool l){
if(!l){
return BUTTON_PRESSED_LEFT;
} else if(!m){
return BUTTON_PRESSED_DOWN;
} else if(!r){
return BUTTON_PRESSED_RIGHT;
} else {
return BUTTON_NOT_PRESSED;
}
}
void update_button_state(){
max7321s_update();
uint8_t rr = max7321s_get_pin(RIGHT_BUTTON_RIGHT);
uint8_t ll = max7321s_get_pin(LEFT_BUTTON_LEFT);
uint8_t rl = max7321s_get_pin(RIGHT_BUTTON_LEFT);
uint8_t lr = max7321s_get_pin(LEFT_BUTTON_RIGHT);
uint8_t rm = gpio_get_level(RIGHT_BUTTON_MID);
uint8_t lm = gpio_get_level(LEFT_BUTTON_MID);
int8_t new_rightbutton = process_button_state(rr, rm, rl);
int8_t new_leftbutton = process_button_state(lr, lm, ll);
if(new_rightbutton != rightbutton){
//TODO: CALLBACK button_state_has_changed_to(new_rightbutton)
//note: consider menubutton/application button config option
}
if(new_leftbutton != leftbutton){
//TODO: CALLBACK button_state_has_changed_to(new_leftbutton)
}
rightbutton = new_rightbutton;
leftbutton = new_leftbutton;
}
#else
#error "spio not implemented for this badge generation"
#endif
void init_buttons(){
_init_buttons();
}
//#define ALWAYS_UPDATE_BUTTON
int8_t get_button_state(bool left){
#ifdef ALWAYS_UPDATE_BUTTON
update_button_state();
#endif
if(left) return leftbutton;
return rightbutton;
}
void spio_menu_button_set_left(bool left){
menu_button_left = 1;
}
int8_t spio_menu_button_get(){
return get_button_state(menu_button_left);
}
int8_t spio_application_button_get(){
return get_button_state(!menu_button_left);
}
int8_t spio_left_button_get(){
return get_button_state(1);
}
int8_t spio_right_button_get(){
return get_button_state(0);
}
int8_t spio_menu_button_get_left(){
return menu_button_left;
}
uint8_t spio_badge_link_get_active(uint8_t pin_mask){
return badge_link_enabled & pin_mask;
}
#if defined(CONFIG_BADGE23_HW_GEN_P1)
static uint8_t spio_badge_link_set(uint8_t pin_mask, uint8_t state){
return 0; // no badge link here (yet)
}
#elif defined(CONFIG_BADGE23_HW_GEN_P3) || defined(CONFIG_BADGE23_HW_GEN_P4) || defined(CONFIG_BADGE23_HW_GEN_P6)
#define USER_WARNINGS_ENABLED
static int8_t spio_badge_link_set(uint8_t pin_mask, bool state){
if(state) {
if((pin_mask & BADGE_LINK_PIN_MASK_LINE_OUT_RING) || (pin_mask & BADGE_LINK_PIN_MASK_LINE_OUT_TIP)){
if(!audio_headphones_are_connected()) {
pin_mask &= ~BADGE_LINK_PIN_MASK_LINE_OUT_RING;
pin_mask &= ~BADGE_LINK_PIN_MASK_LINE_OUT_TIP;
#ifdef USER_WARNINGS_ENABLED
printf("cannot enable line out badge link without cable plugged in for safety reasons\n");
} else {
printf("badge link enabled on line out. please make sure not to have headphones or sound sources connected before transmitting data.\n");
#endif
}
}
}
#ifdef ENABLE_INVERTED
uint8_t hw_state = state;
#else
uint8_t hw_state = !state;
#endif
if(pin_mask & BADGE_LINK_PIN_MASK_LINE_IN_RING) max7321s_set_pinmode_output(BADGE_LINK_LINE_IN_RING_ENABLE_PIN, 1);
if(pin_mask & BADGE_LINK_PIN_MASK_LINE_IN_TIP) max7321s_set_pinmode_output(BADGE_LINK_LINE_IN_TIP_ENABLE_PIN, 1);
if(pin_mask & BADGE_LINK_PIN_MASK_LINE_OUT_RING) max7321s_set_pinmode_output(BADGE_LINK_LINE_OUT_RING_ENABLE_PIN, 1);
if(pin_mask & BADGE_LINK_PIN_MASK_LINE_OUT_TIP) max7321s_set_pinmode_output(BADGE_LINK_LINE_OUT_TIP_ENABLE_PIN, 1);
if(pin_mask & BADGE_LINK_PIN_MASK_LINE_IN_RING) max7321s_set_pin(BADGE_LINK_LINE_IN_RING_ENABLE_PIN, hw_state);
if(pin_mask & BADGE_LINK_PIN_MASK_LINE_IN_TIP) max7321s_set_pin(BADGE_LINK_LINE_IN_TIP_ENABLE_PIN, hw_state);
if(pin_mask & BADGE_LINK_PIN_MASK_LINE_OUT_RING) max7321s_set_pin(BADGE_LINK_LINE_OUT_RING_ENABLE_PIN, hw_state);
if(pin_mask & BADGE_LINK_PIN_MASK_LINE_OUT_TIP) max7321s_set_pin(BADGE_LINK_LINE_OUT_TIP_ENABLE_PIN, hw_state);
max7321s_update();
badge_link_enabled = (badge_link_enabled & (~pin_mask)) | (pin_mask & (hw_state ? 255 : 0));
return spio_badge_link_get_active(pin_mask);
}
#endif
uint8_t spio_badge_link_disable(uint8_t pin_mask){
return spio_badge_link_set(pin_mask, 0);
}
uint8_t spio_badge_link_enable(uint8_t pin_mask){
return spio_badge_link_set(pin_mask, 1);
}
#include "badge23/synth.h"
#include "badge23/audio.h"
#include <math.h>
float ks_osc(ks_osc_t * ks, float input){
//TODO: FIX THIS
ks->real_feedback = ks->feedback;
float delay_time = ((float) (SAMPLE_RATE))/ks->freq;
if(delay_time >= (KS_BUFFER_SIZE)) delay_time = (KS_BUFFER_SIZE) - 1;
//ks->tape[0] = input + real_feedback * ks->tape[delay_time];
return ks->tape[0];
}
float waveshaper(uint8_t shape, float in);
float nes_noise(uint16_t * reg, uint8_t mode, uint8_t run);
void run_trad_env(trad_osc_t * osc){
switch(osc->env_phase){
case 0:
osc->env = 0; osc->counter = 0; osc->env_counter = 0;
break;
case 1:
if(osc->attack_steps){
if(osc->env == 0){
osc->env = (TRAD_OSC_MIN_ATTACK_ENV);
} else {
osc->env_counter++;
if(osc->env_counter > osc->attack_steps){
osc->env *= (1. + (TRAD_OSC_ATTACK_STEP));
osc->env_counter = 0;
}
}
} else {
osc->env += osc->vol/TRAD_OSC_ATTACK_POP_BLOCK;
}
if(osc->env > osc->vol){
osc->env_phase = 2;
osc->env = osc->vol;
}
break;
case 2:
osc->env = osc->vol;
osc->env_counter = 0;
if(osc->skip_hold) osc->env_phase = 3;
break;
case 3:
if(osc->decay_steps){
osc->env_counter++;
if(osc->env_counter > osc->decay_steps){
osc->env *= (1. - (TRAD_OSC_DECAY_STEP));
osc->env_counter = 0;
}
if(osc->env < osc->gate){
osc->env_phase = 0; osc->env = 0; osc->counter = 0;
}
} else {
osc->env_phase = 0; osc->env = 0; osc->counter = 0;
}
break;
}
}
float run_trad_osc(trad_osc_t * osc){
run_trad_env(osc);
if(!osc->env_phase) return 0;
float ret = 0;
//run core sawtooth
float freq = osc->freq * osc->bend;
if(freq > 10000) freq = 10000;
if(freq < -10000) freq = -10000;
if(freq != freq) freq = 0;
osc->counter += 2. * freq / ((float)(SAMPLE_RATE));
if(osc->counter != osc->counter){
printf("trad_osc counter is NaN");
abort();
}
while(osc->counter > 1.){
osc->counter -= 2.;
osc->overflow_event = 1;
}
while(osc->counter < -1.){
osc->counter += 2.;
osc->overflow_event = -1;
}
if(osc->waveform >= 7){
ret = nes_noise(&(osc->noise_reg), osc->waveform == 7, osc->overflow_event);
osc->overflow_event = 0;
} else {
//apply waveshaper
ret = waveshaper(osc->waveform, osc->counter);
}
//apply volume
ret *= osc->env;
return ret;
}
float nes_noise(uint16_t * reg, uint8_t mode, uint8_t run){
if(run) {
uint8_t fb = *reg;
if(mode){
fb = fb>>6;
} else {
fb = fb>>1;
}
fb = (fb ^ (*reg)) & 1;
*reg = (*reg >> 1);
*reg = (*reg) | (((uint16_t) fb) << 14);
}
return ((float) ((*reg) & 1)) * 2 - 1;
}
float waveshaper(uint8_t shape, float in){
//expects sawtooth input in [-1..1] range
switch(shape){
case 0: // TODO: implement proper sine
in = sin(in * 3.1415);
break;
case 1: //fast sine
in = waveshaper(2, in);
if(in > 0.){
in = 1. - in;
in *= in;
in = 1. - in;
} else {
in = 1. + in;
in *= in;
in = in - 1.;
}
break;
case 2: //triangle
in += 0.5;
if(in > 1.0) in -= 2;
if(in > 0.) in = -in;
in = (2. * in) + 1.;
break;
case 3: //sawtooth
break;
case 4: //square
if(in > 0){
in = 1.;
} else {
in = -1.;
}
break;
case 5: //33% pulse
if(in > 0.33){
in = 1.;
} else {
in = -1.;
}
break;
case 6: //25% pulse
if(in > 0.5){
in = 1.;
} else {
in = -1.;
}
break;
}
return in;
}
#define NAT_LOG_SEMITONE 0.05776226504666215
void trad_osc_set_freq_semitone(trad_osc_t * osc, float bend){
osc->freq = 440. * exp(bend * NAT_LOG_SEMITONE);
}
void trad_osc_set_freq_Hz(trad_osc_t * osc, float freq){
osc->freq = freq;
}
void trad_osc_set_waveform(trad_osc_t * osc, uint8_t waveform){
osc->waveform = waveform;
}
void trad_osc_set_attack(trad_osc_t * osc, uint16_t attack){
osc->attack_steps = attack;
}
void trad_osc_set_decay(trad_osc_t * osc, uint16_t decay){
osc->decay_steps = decay;
}
void trad_env_stop(trad_osc_t * osc){
if(osc->env_phase) osc->env_phase = 3;
}
void trad_env_fullstop(trad_osc_t * osc){
osc->env_phase = 0; //stop and skip decay phase
}
void trad_env_start(trad_osc_t * osc){
osc->env_phase = 1; //put into attack phase;
}
!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/
!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/
!_TAG_OUTPUT_EXCMD mixed /number, pattern, mixed, or combineV2/
!_TAG_OUTPUT_FILESEP slash /slash or backslash/
!_TAG_OUTPUT_MODE u-ctags /u-ctags or e-ctags/
!_TAG_PATTERN_LENGTH_LIMIT 96 /0 for no limit/
!_TAG_PROC_CWD /home/zjfms/fluff/badge2023/bootstrap/software/espan/main/ //
!_TAG_PROGRAM_AUTHOR Universal Ctags Team //
!_TAG_PROGRAM_NAME Universal Ctags /Derived from Exuberant Ctags/
!_TAG_PROGRAM_URL https://ctags.io/ /official site/
!_TAG_PROGRAM_VERSION 5.9.0 /p5.9.20220828.0/
AD7147_BASE_ADDR captouch.c /^#define AD7147_BASE_ADDR /;" d file:
AD7147_REG_DEVICE_ID captouch.c /^#define AD7147_REG_DEVICE_ID /;" d file:
AD7147_REG_PWR_CONTROL captouch.c /^#define AD7147_REG_PWR_CONTROL /;" d file:
AD7147_REG_STAGE_CAL_EN captouch.c /^#define AD7147_REG_STAGE_CAL_EN /;" d file:
AD7147_REG_STAGE_HIGH_INT_ENABLE captouch.c /^#define AD7147_REG_STAGE_HIGH_INT_ENABLE /;" d file:
CIN captouch.c /^#define CIN /;" d file:
CIN_BIAS captouch.c /^#define CIN_BIAS /;" d file:
CIN_CDC_NEG captouch.c /^#define CIN_CDC_NEG /;" d file:
CIN_CDC_POS captouch.c /^#define CIN_CDC_POS /;" d file:
CONFIG_I2C_MASTER_SCL Kconfig.projbuild /^ config I2C_MASTER_SCL$/;" c menu:Example Configuration
CONFIG_I2C_MASTER_SCL_MODULE Kconfig.projbuild /^ config I2C_MASTER_SCL$/;" c menu:Example Configuration
CONFIG_I2C_MASTER_SDA Kconfig.projbuild /^ config I2C_MASTER_SDA$/;" c menu:Example Configuration
CONFIG_I2C_MASTER_SDA_MODULE Kconfig.projbuild /^ config I2C_MASTER_SDA$/;" c menu:Example Configuration
DEF_apa102LEDStrip apa102LEDStrip.h /^#define DEF_apa102LEDStrip$/;" d
DMA_BUFFER_COUNT audio.c /^#define DMA_BUFFER_COUNT /;" d file:
DMA_BUFFER_SIZE audio.c /^#define DMA_BUFFER_SIZE /;" d file:
ESP_INTR_FLAG_DEFAULT captouch.c /^#define ESP_INTR_FLAG_DEFAULT /;" d file:
Example Configuration Kconfig.projbuild /^menu "Example Configuration"$/;" m
I2C_MASTER_FREQ_HZ espan.c /^#define I2C_MASTER_FREQ_HZ /;" d file:
I2C_MASTER_NUM captouch.c /^#define I2C_MASTER_NUM /;" d file:
I2C_MASTER_NUM espan.c /^#define I2C_MASTER_NUM /;" d file:
I2C_MASTER_RX_BUF_DISABLE espan.c /^#define I2C_MASTER_RX_BUF_DISABLE /;" d file:
I2C_MASTER_SCL Kconfig.projbuild /^ config I2C_MASTER_SCL$/;" c menu:Example Configuration
I2C_MASTER_SCL_IO espan.c /^#define I2C_MASTER_SCL_IO /;" d file:
I2C_MASTER_SDA Kconfig.projbuild /^ config I2C_MASTER_SDA$/;" c menu:Example Configuration
I2C_MASTER_SDA_IO espan.c /^#define I2C_MASTER_SDA_IO /;" d file:
I2C_MASTER_TX_BUF_DISABLE espan.c /^#define I2C_MASTER_TX_BUF_DISABLE /;" d file:
LEDs apa102LEDStrip.h /^ unsigned char *LEDs;$/;" m struct:apa102LEDStrip typeref:typename:unsigned char *
MIN audio.c /^#define MIN(/;" d file:
SAMPLE_RATE audio.c /^#define SAMPLE_RATE /;" d file:
TAG captouch.c /^static const char *TAG = "captouch";$/;" v typeref:typename:const char * file:
TAG espan.c /^static const char *TAG = "espan";$/;" v typeref:typename:const char * file:
TIMEOUT_MS captouch.c /^#define TIMEOUT_MS /;" d file:
_audio_init audio.c /^static void _audio_init(int i2s_num) {$/;" f typeref:typename:void file:
_bytesPerLED apa102LEDStrip.h /^ unsigned char _bytesPerLED;$/;" m struct:apa102LEDStrip typeref:typename:unsigned char
_counter apa102LEDStrip.h /^ short int _counter;$/;" m struct:apa102LEDStrip typeref:typename:short int
_endFrameLength apa102LEDStrip.h /^ short int _endFrameLength;$/;" m struct:apa102LEDStrip typeref:typename:short int
_frameLength apa102LEDStrip.h /^ short int _frameLength;$/;" m struct:apa102LEDStrip typeref:typename:short int
_globalBrightness apa102LEDStrip.h /^ unsigned char _globalBrightness;$/;" m struct:apa102LEDStrip typeref:typename:unsigned char
_numLEDs apa102LEDStrip.h /^ short int _numLEDs;$/;" m struct:apa102LEDStrip typeref:typename:short int
active_paddles espan.c /^static bool active_paddles[10];$/;" v typeref:typename:bool[10] file:
active_sounds audio.c /^static sound_cfg_t active_sounds[11];$/;" v typeref:typename:sound_cfg_t[11] file:
ad7147_device_config captouch.c /^struct ad7147_device_config {$/;" s file:
ad7147_stage_config captouch.c /^struct ad7147_stage_config {$/;" s file:
ad714x_chip captouch.c /^struct ad714x_chip {$/;" s file:
ad714x_default_config captouch.c /^static struct ad7147_stage_config ad714x_default_config(void)$/;" f typeref:struct:ad7147_stage_config file:
ad714x_i2c_read captouch.c /^static esp_err_t ad714x_i2c_read(const struct ad714x_chip *chip, const uint16_t reg, uint16_t *d/;" f typeref:typename:esp_err_t file:
ad714x_i2c_write captouch.c /^static esp_err_t ad714x_i2c_write(const struct ad714x_chip *chip, const uint16_t reg, const uint/;" f typeref:typename:esp_err_t file:
ad714x_set_device_config captouch.c /^static void ad714x_set_device_config(const struct ad714x_chip *chip, const struct ad7147_device_/;" f typeref:typename:void file:
ad714x_set_stage_config captouch.c /^static void ad714x_set_stage_config(const struct ad714x_chip *chip, const uint8_t stage, const s/;" f typeref:typename:void file:
addr captouch.c /^ uint8_t addr;$/;" m struct:ad714x_chip typeref:typename:uint8_t file:
afe_offsets captouch.c /^ int afe_offsets[13];$/;" m struct:ad714x_chip typeref:typename:int[13] file:
apa102LEDStrip apa102LEDStrip.h /^struct apa102LEDStrip$/;" s
app_main espan.c /^void app_main(void)$/;" f typeref:typename:void
audio_init audio.c /^void audio_init() { _audio_init(0); }$/;" f typeref:typename:void
audio_player_task audio.c /^static void audio_player_task(void* arg) {$/;" f typeref:typename:void file:
avg_fp_skip captouch.c /^ unsigned int avg_fp_skip:2;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:2 file:
avg_lp_skip captouch.c /^ unsigned int avg_lp_skip:2;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:2 file:
bank2 captouch.c /^static const uint16_t bank2 = 0x80;$/;" v typeref:typename:const uint16_t file:
black espan.c /^uint8_t black[] = {0,0,0};$/;" v typeref:typename:uint8_t[]
blue espan.c /^uint8_t blue[] = {0,0,32};$/;" v typeref:typename:uint8_t[]
bot_map espan.c /^uint8_t bot_map[] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4};$/;" v typeref:typename:uint8_t[]
buffer audio.c /^ const int16_t* buffer;$/;" m struct:sound_cfg typeref:typename:const int16_t * file:
buscfg espan.c /^spi_bus_config_t buscfg;$/;" v typeref:typename:spi_bus_config_t
bytesPerPixel espan.c /^#define bytesPerPixel /;" d file:
captouch_init captouch.c /^void captouch_init(void)$/;" f typeref:typename:void
captouch_init_chip captouch.c /^static void captouch_init_chip(const struct ad714x_chip* chip)$/;" f typeref:typename:void file:
captouch_print_debug_info captouch.c /^void captouch_print_debug_info(void)$/;" f typeref:typename:void
captouch_print_debug_info_chip captouch.c /^static void captouch_print_debug_info_chip(const struct ad714x_chip* chip)$/;" f typeref:typename:void file:
cdc_bias captouch.c /^ unsigned int cdc_bias:2;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:2 file:
chip_bot captouch.c /^static const struct ad714x_chip chip_bot = {.addr = AD7147_BASE_ADDR, .gpio = 3, .afe_offsets = /;" v typeref:typename:const struct ad714x_chip file:
chip_top captouch.c /^static const struct ad714x_chip chip_top = {.addr = AD7147_BASE_ADDR + 1, .gpio = 48, .afe_offse/;" v typeref:typename:const struct ad714x_chip file:
cinX_connection_setup captouch.c /^ unsigned int cinX_connection_setup[13];$/;" m struct:ad7147_stage_config typeref:typename:unsigned int[13] file:
decimation captouch.c /^ unsigned int decimation:2;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:2 file:
devcfg espan.c /^spi_device_interface_config_t devcfg;$/;" v typeref:typename:spi_device_interface_config_t
espan_handle_captouch espan.c /^void espan_handle_captouch(uint16_t pressed_top, uint16_t pressed_bot)$/;" f typeref:typename:void
ext_source captouch.c /^ unsigned int ext_source:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
free_buffer audio.c /^ bool free_buffer;$/;" m struct:sound_cfg typeref:typename:bool file:
getPixel apa102LEDStrip.c /^void getPixel(struct apa102LEDStrip *ledObject, short int pixelIndex, unsigned char *pixelColour/;" f typeref:typename:void
gpio captouch.c /^ uint8_t gpio;$/;" m struct:ad714x_chip typeref:typename:uint8_t file:
gpio_event_handler captouch.c /^static void gpio_event_handler(void* arg)$/;" f typeref:typename:void file:
gpio_evt_queue captouch.c /^static QueueHandle_t gpio_evt_queue = NULL;$/;" v typeref:typename:QueueHandle_t file:
gpio_isr_handler captouch.c /^static void IRAM_ATTR gpio_isr_handler(void* arg)$/;" f typeref:typename:void IRAM_ATTR file:
i2c_master_init espan.c /^static esp_err_t i2c_master_init(void)$/;" f typeref:typename:esp_err_t file:
initLEDs apa102LEDStrip.c /^void initLEDs(struct apa102LEDStrip *ledObject, short int numLEDs, unsigned char bytesPerLED, un/;" f typeref:typename:void
int_pol captouch.c /^ unsigned int int_pol:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
leds espan.c /^struct apa102LEDStrip leds;$/;" v typeref:struct:apa102LEDStrip
lp_conv_delay captouch.c /^ unsigned int lp_conv_delay:2;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:2 file:
maxSPIFrameInBytes espan.c /^#define maxSPIFrameInBytes /;" d file:
maxSPIFrequency espan.c /^#define maxSPIFrequency /;" d file:
maxValuePerColour espan.c /^#define maxValuePerColour /;" d file:
neg_afe_offset captouch.c /^ unsigned int neg_afe_offset:6;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:6 file:
neg_afe_offset_disable captouch.c /^ unsigned int neg_afe_offset_disable:1;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:1 file:
neg_afe_offset_swap captouch.c /^ unsigned int neg_afe_offset_swap:1;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:1 file:
neg_peak_detect captouch.c /^ unsigned int neg_peak_detect:3;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:3 file:
neg_threshold_sensitivity captouch.c /^ unsigned int neg_threshold_sensitivity:4;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:4 file:
paddle_leds espan.c /^static const uint8_t paddle_leds[][9] = {$/;" v typeref:typename:const uint8_t[][9] file:
play_bootsound audio.c /^void play_bootsound() {$/;" f typeref:typename:void
play_pan audio.c /^void play_pan(int pan) {$/;" f typeref:typename:void
pos_afe_offset captouch.c /^ unsigned int pos_afe_offset:6;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:6 file:
pos_afe_offset_disable captouch.c /^ unsigned int pos_afe_offset_disable:1;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:1 file:
pos_afe_offset_swap captouch.c /^ unsigned int pos_afe_offset_swap:1;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:1 file:
pos_peak_detect captouch.c /^ unsigned int pos_peak_detect:3;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:3 file:
pos_threshold_sensitivity captouch.c /^ unsigned int pos_threshold_sensitivity:4;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:4 file:
position audio.c /^ size_t position;$/;" m struct:sound_cfg typeref:typename:size_t file:
power_mode captouch.c /^ unsigned int power_mode:2;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:2 file:
pressed_bot captouch.c /^static uint16_t pressed_top, pressed_bot;$/;" v typeref:typename:uint16_t file:
pressed_top captouch.c /^static uint16_t pressed_top, pressed_bot;$/;" v typeref:typename:uint16_t file:
red espan.c /^uint8_t red[] = {32,0,0};$/;" v typeref:typename:uint8_t[]
renderLEDs espan.c /^void renderLEDs()$/;" f typeref:typename:void
ret espan.c /^esp_err_t ret;$/;" v typeref:typename:esp_err_t
se_connection_setup captouch.c /^ unsigned int se_connection_setup:2;$/;" m struct:ad7147_stage_config typeref:typename:unsigned int:2 file:
sequence_stage_num captouch.c /^ unsigned int sequence_stage_num:4;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:4 file:
setPixel apa102LEDStrip.c /^void setPixel(struct apa102LEDStrip *ledObject, short int pixelIndex, unsigned char *pixelColour/;" f typeref:typename:void
setupSPI espan.c /^int setupSPI()$/;" f typeref:typename:int
size audio.c /^ size_t size;$/;" m struct:sound_cfg typeref:typename:size_t file:
slot audio.c /^ size_t slot;$/;" m struct:sound_cfg typeref:typename:size_t file:
sound_active audio.c /^static bool sound_active(void)$/;" f typeref:typename:bool file:
sound_cfg audio.c /^typedef struct sound_cfg {$/;" s file:
sound_cfg_t audio.c /^} sound_cfg_t;$/;" t typeref:struct:sound_cfg file:
sound_queue audio.c /^static QueueHandle_t sound_queue = NULL;$/;" v typeref:typename:QueueHandle_t file:
spiTransObject espan.c /^spi_transaction_t spiTransObject;$/;" v typeref:typename:spi_transaction_t
spi_led espan.c /^spi_device_handle_t spi_led;$/;" v typeref:typename:spi_device_handle_t
stage0_cal_en captouch.c /^ unsigned int stage0_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage0_high_int_enable captouch.c /^ unsigned int stage0_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage10_cal_en captouch.c /^ unsigned int stage10_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage10_high_int_enable captouch.c /^ unsigned int stage10_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage11_cal_en captouch.c /^ unsigned int stage11_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage11_high_int_enable captouch.c /^ unsigned int stage11_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage1_cal_en captouch.c /^ unsigned int stage1_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage1_high_int_enable captouch.c /^ unsigned int stage1_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage2_cal_en captouch.c /^ unsigned int stage2_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage2_high_int_enable captouch.c /^ unsigned int stage2_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage3_cal_en captouch.c /^ unsigned int stage3_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage3_high_int_enable captouch.c /^ unsigned int stage3_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage4_cal_en captouch.c /^ unsigned int stage4_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage4_high_int_enable captouch.c /^ unsigned int stage4_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage5_cal_en captouch.c /^ unsigned int stage5_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage5_high_int_enable captouch.c /^ unsigned int stage5_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage6_cal_en captouch.c /^ unsigned int stage6_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage6_high_int_enable captouch.c /^ unsigned int stage6_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage7_cal_en captouch.c /^ unsigned int stage7_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage7_high_int_enable captouch.c /^ unsigned int stage7_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage8_cal_en captouch.c /^ unsigned int stage8_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage8_high_int_enable captouch.c /^ unsigned int stage8_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage9_cal_en captouch.c /^ unsigned int stage9_cal_en:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stage9_high_int_enable captouch.c /^ unsigned int stage9_high_int_enable:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
stages captouch.c /^ int stages;$/;" m struct:ad714x_chip typeref:typename:int file:
sw_reset captouch.c /^ unsigned int sw_reset:1;$/;" m struct:ad7147_device_config typeref:typename:unsigned int:1 file:
top_map espan.c /^uint8_t top_map[] = {1, 1, 1, 0, 0, 4, 4, 4, 3, 3, 2, 2};$/;" v typeref:typename:uint8_t[]
totalPixels espan.c /^#define totalPixels /;" d file:
Checks: '-*,clang-analyzer-osx.SecKeychainAPI'