forked from W4D/soundcube-firmware
477 lines
12 KiB
C++
477 lines
12 KiB
C++
|
|
#include <ArduinoJson.h>
|
|
#include <ArduinoJson.hpp>
|
|
|
|
#include <TCA9555.h>
|
|
#include <AS5600.h>
|
|
#include <DAC8552.h>
|
|
|
|
#include <FastLED.h>
|
|
#include <PWMAudio.h>
|
|
#include <I2S.h>
|
|
#include <SPI.h>
|
|
#include <SD.h>
|
|
#include "codec.h"
|
|
#include "wavestream.h"
|
|
|
|
#define HAPTIC 1
|
|
#define AURAL 1
|
|
#define UI_SAMPLERATE 22050
|
|
|
|
#define BUFFERSIZE 64
|
|
#define NSTREAMS 8
|
|
|
|
int16_t buffer[BUFFERSIZE];
|
|
|
|
WaveStream stream[NSTREAMS];
|
|
|
|
bool streams_loaded = false;
|
|
|
|
I2S i2s(INPUT_PULLUP);
|
|
|
|
TLV320AIC3204 codec;
|
|
|
|
TCA9555 TCA(0x20, &Wire1);
|
|
AS5600 ENC(&Wire1);
|
|
|
|
DAC8552 dac(9, &SPI1);
|
|
|
|
PWMAudio ui_snd(8);
|
|
|
|
enum BUTTON {CVINL, CVINR, INL, INR, OUTR, OUTL, CVOUTR, CVOUTL, RIGHT, LEFT, SELECT, DEBUG1, DEBUG2, DEBUG3};
|
|
|
|
int lut_ring_cw[48] = {39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,50,49,48,47,46,45,44,43,42,41,40};
|
|
int lut_ring_ccw[48] = {40,41,42,43,44,45,46,47,48,49,50,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39};
|
|
int lut_matrix[13] = {56,55,57,58,59,62,61,60,63,64,65,67,66};
|
|
|
|
int active = 0;
|
|
int active_led_ring = 0;
|
|
|
|
bool speakerToggle = false;
|
|
|
|
uint32_t lastTime = 0;
|
|
int32_t position = 0;
|
|
|
|
CRGB ui_leds[74];
|
|
CRGB edge_leds[11];
|
|
|
|
volatile bool buttonChanged = false;
|
|
volatile bool ui_click = false;
|
|
volatile bool ui_beep = false;
|
|
volatile bool amp = false;
|
|
|
|
int counter = 0;
|
|
|
|
bool buttons[16] = {false};
|
|
|
|
int16_t ui_click_snd[UI_SAMPLERATE];
|
|
uint16_t click_length = 0;
|
|
|
|
int16_t ui_beep_snd[UI_SAMPLERATE];
|
|
uint16_t beep_length = 0;
|
|
|
|
bool sd_card_detected = false;
|
|
|
|
struct Color {
|
|
int r;
|
|
int g;
|
|
int b;
|
|
int r_active;
|
|
int g_active;
|
|
int b_active;
|
|
};
|
|
|
|
struct Config {
|
|
Color edge_color = {0,0,50,0,50,0};
|
|
Color ring_color = {0,50,50,0,80,50};
|
|
};
|
|
|
|
Config config;
|
|
|
|
void loadConfiguration(Config& config) {
|
|
File file = SD.open("/config.txt");
|
|
JsonDocument doc;
|
|
|
|
DeserializationError error = deserializeJson(doc, file);
|
|
if(error) Serial.println(F("Failed to read file, using default configuration"));
|
|
|
|
config.edge_color.r = doc["edge"]["color"]["idle"]["r"] | 0;
|
|
config.edge_color.g = doc["edge"]["color"]["idle"]["g"] | 0;
|
|
config.edge_color.b = doc["edge"]["color"]["idle"]["b"] | 50;
|
|
config.edge_color.r_active = doc["edge"]["color"]["active"]["r"] | 0;
|
|
config.edge_color.g_active = doc["edge"]["color"]["active"]["g"] | 50;
|
|
config.edge_color.b_active = doc["edge"]["color"]["active"]["b"] | 0;
|
|
|
|
config.ring_color.r = doc["ring"]["color"]["idle"]["r"] | 0;
|
|
config.ring_color.g = doc["ring"]["color"]["idle"]["g"] | 50;
|
|
config.ring_color.b = doc["ring"]["color"]["idle"]["b"] | 50;
|
|
config.ring_color.r_active = doc["ring"]["color"]["active"]["r"] | 0;
|
|
config.ring_color.g_active = doc["ring"]["color"]["active"]["g"] | 80;
|
|
config.ring_color.b_active = doc["ring"]["color"]["active"]["b"] | 50;
|
|
|
|
//strlcpy(config.hostname, doc["hostname"] | "example.com", sizeof(config.hostname));
|
|
|
|
file.close();
|
|
}
|
|
|
|
size_t count;
|
|
size_t tape_write = 0;
|
|
|
|
void codec_transmit() {
|
|
for(int i = 0; i < count; i++){
|
|
int j = active % NSTREAMS;
|
|
for(int k = 0; k < NSTREAMS; k++){
|
|
int16_t sample = 0;
|
|
sample = stream[k].get();
|
|
buffer[i] += sample >> 2;
|
|
}
|
|
}
|
|
i2s.write((const uint8_t *)&buffer, count * sizeof(int16_t));
|
|
}
|
|
|
|
void codec_receive(){
|
|
count = i2s.read((uint8_t *)&buffer, BUFFERSIZE * sizeof(int16_t)) * sizeof(uint32_t) / sizeof(int16_t);
|
|
for(int i = 0; i < count; i++){
|
|
buffer[i] *= -1;
|
|
}
|
|
}
|
|
|
|
void pwm_audio_callback() {
|
|
while (ui_snd.availableForWrite()) {
|
|
if(ui_click || ui_beep) {
|
|
if(ui_beep) {
|
|
ui_snd.write(ui_beep_snd[counter]);
|
|
counter++;
|
|
if(counter == beep_length) {
|
|
counter = 0;
|
|
ui_beep = false;
|
|
}
|
|
continue;
|
|
}
|
|
if(ui_click) {
|
|
ui_snd.write(ui_click_snd[counter]);
|
|
counter++;
|
|
if(counter == click_length) {
|
|
counter = 0;
|
|
ui_click = false;
|
|
}
|
|
}
|
|
} else {
|
|
digitalWrite(7, LOW);
|
|
ui_snd.write(0);
|
|
counter = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool load_ui_sounds(const char* file, int16_t *buffer, uint16_t &length){
|
|
if(SD.exists(file)) {
|
|
File f_click = SD.open(file);
|
|
f_click.seek(44, SeekSet);
|
|
int click_bytes = 0;
|
|
while (f_click.available() && click_bytes < UI_SAMPLERATE) {
|
|
uint8_t samplebyte[2];
|
|
f_click.read(samplebyte, 2);
|
|
int16_t sample = (samplebyte[1] << 8) + samplebyte[0];
|
|
buffer[click_bytes] = sample;
|
|
click_bytes++;
|
|
}
|
|
f_click.close();
|
|
length = click_bytes;
|
|
return true;
|
|
} else {
|
|
for(int i = 0; i < UI_SAMPLERATE; i++){
|
|
float sine_pos = (2.0f * M_PI * 3000.0f * (float)i) / (float)UI_SAMPLERATE;
|
|
buffer[i] = (int16_t)(sin(sine_pos) * 8000.0f);
|
|
}
|
|
Serial.println("Synthesized 8kHz sine into beep array.");
|
|
length = UI_SAMPLERATE;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void tca_irq() {
|
|
buttonChanged = true;
|
|
}
|
|
|
|
void speaker(bool state){
|
|
digitalWrite(12, state ? HIGH : LOW);
|
|
digitalWrite(13, state ? HIGH : LOW);
|
|
}
|
|
|
|
void setup() {
|
|
Serial.begin();
|
|
delay(1000);
|
|
|
|
i2s.setFrequency(48000);
|
|
|
|
SPI1.setSCK(10);
|
|
SPI1.setTX(11);
|
|
SPI1.begin();
|
|
|
|
dac.begin();
|
|
|
|
FastLED.addLeds<NEOPIXEL, 4>(edge_leds, 11);
|
|
FastLED.addLeds<NEOPIXEL, 5>(ui_leds, 74);
|
|
|
|
pinMode(12, OUTPUT);
|
|
pinMode(13, OUTPUT);
|
|
|
|
speaker(false);
|
|
|
|
pinMode(21, INPUT_PULLUP);
|
|
sd_card_detected = !digitalRead(21);
|
|
delay(500);
|
|
|
|
bool sdInitialized = SD.begin(22, 23, 24);
|
|
delay(100);
|
|
if(!sdInitialized) sdInitialized = SD.begin(22, 23, 24); // hack to prevent SD card from not initializing after soft reset
|
|
|
|
if(sdInitialized) loadConfiguration(config);
|
|
|
|
if(sdInitialized){
|
|
load_ui_sounds("/ui/click.wav", ui_click_snd, click_length);
|
|
load_ui_sounds("/ui/beep.wav", ui_beep_snd, beep_length);
|
|
}
|
|
|
|
Serial.println("INIT WIRE");
|
|
Wire1.setSDA(2);
|
|
Wire1.setSCL(3);
|
|
Wire1.begin();
|
|
Serial.println("SUCCESS");
|
|
|
|
Serial.println("INIT TCA");
|
|
TCA.begin();
|
|
TCA.pinMode16(0xFFFF);
|
|
TCA.setPolarity16(0x0000);
|
|
Serial.println("SUCCESS");
|
|
|
|
Serial.println("INIT INTERRUPT");
|
|
pinMode(1, INPUT_PULLUP);
|
|
attachInterrupt(digitalPinToInterrupt(1), tca_irq, FALLING);
|
|
Serial.println("SUCCESS");
|
|
|
|
// Rotary Encoder
|
|
ENC.begin(); // set direction pin.
|
|
ENC.setDirection(AS5600_COUNTERCLOCK_WISE);
|
|
|
|
pinMode(6, OUTPUT); // Vibration Motor
|
|
pinMode(7, OUTPUT); // UI Amp Enable
|
|
|
|
ui_snd.onTransmit(pwm_audio_callback);
|
|
ui_snd.begin(UI_SAMPLERATE);
|
|
|
|
digitalWrite(7, LOW); // UI amp off
|
|
|
|
pinMode(19, OUTPUT); // MCLK enable
|
|
digitalWrite(19, HIGH); // enable MCLK
|
|
|
|
pinMode(20, OUTPUT); // CODEC reset
|
|
digitalWrite(20, HIGH);
|
|
|
|
codec.begin(&Wire1);
|
|
|
|
i2s.onTransmit(codec_transmit);
|
|
i2s.onReceive(codec_receive);
|
|
|
|
i2s.setDOUT(15);
|
|
i2s.setDIN(14);
|
|
i2s.setBCLK(16); // Note: LRCLK = BCLK + 1
|
|
i2s.setMCLK(18);
|
|
i2s.setMCLKmult(512); // 256 = 12.288.000Hz 512 = 25Mhz
|
|
|
|
i2s.swapClocks();
|
|
i2s.setBitsPerSample(16);
|
|
|
|
i2s.setBuffers(6, BUFFERSIZE * sizeof(int16_t) / sizeof(uint32_t));
|
|
|
|
if(!i2s.begin(48000)){
|
|
Serial.println("I2S error!");
|
|
while(100);
|
|
}
|
|
|
|
if(sdInitialized) {
|
|
for(int i = 0; i < NSTREAMS; i++){
|
|
stream[i].begin();
|
|
char filename[40];
|
|
sprintf(filename, "/sound/%d.wav", i+1);
|
|
if(SD.exists(filename)){
|
|
bool loaded = stream[i].load(SD.open(filename));
|
|
|
|
if(loaded) {
|
|
Serial.print("file read: ");
|
|
Serial.print(stream[i].wavefile.length);
|
|
Serial.print(" bytes | ");
|
|
Serial.print(stream[i].wavefile.samplerate);
|
|
Serial.print(" kHz | ");
|
|
Serial.print(stream[i].wavefile.bitspersample);
|
|
Serial.print(" bits | ");
|
|
Serial.print(stream[i].wavefile.channels);
|
|
Serial.print(" channels | ");
|
|
Serial.print(stream[i].wavefile.blockalign);
|
|
Serial.println(" bytes");
|
|
|
|
//stream[i].play();
|
|
stream[i].wavefile.loop = true;
|
|
} else {
|
|
Serial.println("file loading error");
|
|
}
|
|
} else {
|
|
for(int k = 0; k < 3; k++){
|
|
digitalWrite(6, HIGH);
|
|
delay(100);
|
|
digitalWrite(6, LOW);
|
|
delay(50);
|
|
}
|
|
}
|
|
}
|
|
streams_loaded = true;
|
|
}
|
|
|
|
digitalWrite(6, HIGH);
|
|
delay(25);
|
|
digitalWrite(6, LOW);
|
|
delay(50);
|
|
digitalWrite(6, HIGH);
|
|
delay(25);
|
|
digitalWrite(6, LOW);
|
|
}
|
|
|
|
bool dactest = false;
|
|
|
|
void loop() {
|
|
position = ENC.getCumulativePosition();
|
|
|
|
sd_card_detected = !digitalRead(21);
|
|
if(sd_card_detected) edge_leds[8] = CRGB(0,10,0);
|
|
if(!sd_card_detected) edge_leds[8] = CRGB(10,0,0);
|
|
|
|
// EDGE LEDs
|
|
for (int i = 0; i < 8; i++) {
|
|
edge_leds[i] = CRGB(config.edge_color.r, config.edge_color.g, config.edge_color.b);
|
|
}
|
|
|
|
// LED Ring leeren
|
|
for (int i = 0; i < 48; i++) {
|
|
ui_leds[i + 3] = CRGB(0, 0, 0);
|
|
}
|
|
|
|
// Rotary button LEDs
|
|
ui_leds[0] = CRGB(0, 0, 0);
|
|
ui_leds[1] = CRGB(0, 0, 0);
|
|
ui_leds[2] = CRGB(0, 0, 0);
|
|
|
|
// buttonChanged = true when a button is pushed
|
|
if (buttonChanged) {
|
|
int buttonValues = TCA.read16();
|
|
|
|
bool buttonsNew[16] = {false};
|
|
int buttonsDir[16] = {0};
|
|
|
|
bool buttonUp = false;
|
|
bool buttonDown = false;
|
|
for(int i = 0; i < 16; i++){
|
|
buttonsNew[i] = ~(buttonValues >> i) & 0x01;
|
|
if(buttonsNew[i] == true && buttons[i] == false) {
|
|
buttonsDir[i] = 1;
|
|
buttonDown = true;
|
|
}
|
|
if(buttonsNew[i] == false && buttons[i] == true) {
|
|
buttonsDir[i] = -1;
|
|
buttonUp = true;
|
|
}
|
|
buttons[i] = buttonsNew[i];
|
|
}
|
|
|
|
// Make vibration
|
|
if (HAPTIC && buttonDown) {
|
|
digitalWrite(6, HIGH);
|
|
delay(50);
|
|
digitalWrite(6, LOW);
|
|
}
|
|
|
|
// Make beep
|
|
if (AURAL && buttonDown) {
|
|
digitalWrite(7, HIGH);
|
|
ui_click = true;
|
|
}
|
|
|
|
// Flash encoder leds
|
|
ui_leds[0] = CRGB(0, 100, 50);
|
|
ui_leds[1] = CRGB(0, 100, 50);
|
|
ui_leds[2] = CRGB(0, 100, 50);
|
|
|
|
// Switch through LED matrix
|
|
if(buttons[RIGHT]) active++;
|
|
if(buttons[LEFT]) active--;
|
|
if(active == 13) active = 0;
|
|
if(active == -1) active = 12;
|
|
|
|
if(buttons[CVINL]) {
|
|
Serial.println("vol down");
|
|
codec.volumeDown();
|
|
}
|
|
|
|
if(buttons[CVOUTL]) {
|
|
Serial.println("vol up");
|
|
codec.volumeUp();
|
|
}
|
|
|
|
if(buttons[DEBUG3]) {
|
|
speakerToggle = !speakerToggle;
|
|
speaker(speakerToggle);
|
|
}
|
|
|
|
if(buttons[DEBUG2]) {
|
|
dactest = !dactest;
|
|
dac.setValue(0, dactest ? 0 : 32768);
|
|
dac.setValue(1, !dactest ? 0 : 65535);
|
|
}
|
|
|
|
if(buttons[SELECT]){
|
|
stream[active % NSTREAMS].toggle();
|
|
ui_beep = true;
|
|
}
|
|
|
|
Serial.println(codec.getVolumeL());
|
|
|
|
//for(int i = 0; i < NSTREAMS; i++){
|
|
// stream[i].pause();
|
|
// }
|
|
//stream[active % NSTREAMS].play();
|
|
|
|
buttonChanged = false;
|
|
}
|
|
|
|
//dac.setValue(0, dactest ? 0 : sin((float)millis() / 100.0f) * 32768 + 32768);
|
|
|
|
// empty LED matrix
|
|
for (int i = 0; i < 13; i++) {
|
|
ui_leds[lut_matrix[i]] = CRGB(0, 0, 0);
|
|
if(stream[i % NSTREAMS].isPlaying()) ui_leds[lut_matrix[i % NSTREAMS]] = CRGB(0, 50, 0);
|
|
}
|
|
|
|
// set active LED matrix LED
|
|
ui_leds[lut_matrix[active]] = CRGB(100, 100, 100);
|
|
|
|
if(position < 0) position += 4096;
|
|
active_led_ring = (position / 32) % 48;
|
|
|
|
// set active LED ring LED
|
|
for(int i = 0; i < active_led_ring; i++){
|
|
ui_leds[lut_ring_ccw[i]] = CRGB(config.ring_color.r, config.ring_color.g, config.ring_color.b);
|
|
}
|
|
|
|
FastLED.show();
|
|
if(streams_loaded) {
|
|
for(int i = 0; i < NSTREAMS; i++){
|
|
stream[i].stream();
|
|
}
|
|
}
|
|
|
|
if(i2s.getOverflow()) Serial.println("overflow");
|
|
if(i2s.getUnderflow()) Serial.println("underflow");
|
|
|
|
//delay(20); // wait 1ms
|
|
|
|
} |