diff --git a/src/AudioOutputULP.cpp b/src/AudioOutputULP.cpp new file mode 100644 index 0000000..d7bc5f2 --- /dev/null +++ b/src/AudioOutputULP.cpp @@ -0,0 +1,258 @@ +/* + AudioOutputULP + Outputs to ESP32 DAC through the ULP, freeing I2S for other uses + + v 0.0.1 (2020-10-01) + + Copyright (C) 2020 Martin Laclaustra, based on bitluni's code + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifdef ESP32 + +#include "AudioOutputULP.h" +#include +#include +#include +#include +#include + +uint32_t create_I_WR_REG(uint32_t reg, uint32_t low_bit, uint32_t high_bit, uint32_t val){ + typedef union {ulp_insn_t ulp_ins; uint32_t ulp_bin;} ulp_union; + const ulp_insn_t singleinstruction[] = {I_WR_REG(reg, low_bit, high_bit, val)}; + ulp_union recover_ins; + recover_ins.ulp_ins=singleinstruction[0]; + return (uint32_t)(recover_ins.ulp_bin); +} + +uint32_t create_I_BXI(uint32_t imm_pc){ + typedef union {ulp_insn_t ulp_ins; uint32_t ulp_bin;} ulp_union; + const ulp_insn_t singleinstruction[] = {I_BXI(imm_pc)}; + ulp_union recover_ins; + recover_ins.ulp_ins=singleinstruction[0]; + return (uint32_t)(recover_ins.ulp_bin); +} + +bool AudioOutputULP::begin() +{ + if(!stereoOutput){ + waitingOddSample = false; + //totalSampleWords += 512; + //dacTableStart2 = dacTableStart1; + } + + //calculate the actual ULP clock + unsigned long rtc_8md256_period = rtc_clk_cal(RTC_CAL_8MD256, 1000); + unsigned long rtc_fast_freq_hz = 1000000ULL * (1 << RTC_CLK_CAL_FRACT) * 256 / rtc_8md256_period; + + //initialize DACs + if(activeDACs & 1){ + dac_output_enable(DAC_CHANNEL_1); + dac_output_voltage(DAC_CHANNEL_1, 128); + } + if(activeDACs & 2){ + dac_output_enable(DAC_CHANNEL_2); + dac_output_voltage(DAC_CHANNEL_2, 128); + } + + int retAddress1 = 9; + int retAddress2 = 14; + + int loopCycles = 120; + int loopHalfCycles1 = 76; + int loopHalfCycles2 = 44; + + Serial.print("Real RTC clock: "); + Serial.println(rtc_fast_freq_hz); + + uint32_t dt = (rtc_fast_freq_hz / hertz) - loopCycles; + uint32_t dt2 = 0; + if(!stereoOutput){ + dt = (rtc_fast_freq_hz / hertz) - loopHalfCycles1; + dt2 = (rtc_fast_freq_hz / hertz) - loopHalfCycles2; + } + + Serial.print("dt: "); + Serial.println(dt); + + Serial.print("dt2: "); + Serial.println(dt2); + + const ulp_insn_t stereo[] = { + //reset offset register + I_MOVI(R3, 0), + //delay to get the right sampling rate + I_DELAY(dt), // 6 + dt + //reset sample index + I_MOVI(R0, 0), // 6 + //write the index back to memory for the main cpu + I_ST(R0, R3, indexAddress), // 8 + //load the samples + I_LD(R1, R0, bufferStart), // 8 + //mask the lower 8 bits + I_ANDI(R2, R1, 0x00ff), // 6 + //multiply by 2 + I_LSHI(R2, R2, 1), // 6 + //add start position + I_ADDI(R2, R2, dacTableStart1),// 6 + //jump to the dac opcode + I_BXR(R2), // 4 + //back from first dac + //delay between the two samples in mono rendering + I_DELAY(dt2), // 6 + dt2 + //mask the upper 8 bits + I_ANDI(R2, R1, 0xff00), // 6 + //shift the upper bits to right and multiply by 2 + I_RSHI(R2, R2, 8 - 1), // 6 + //add start position of second dac table + I_ADDI(R2, R2, dacTableStart2),// 6 + //jump to the dac opcode + I_BXR(R2), // 4 + //here we get back from writing the second sample + //increment the sample index + I_ADDI(R0, R0, 1), // 6 + //if reached end of the buffer, jump relative to index reset + I_BGE(-14, totalSampleWords), // 4 + //wait to get the right sample rate (2 cycles more to compensate the index reset) + I_DELAY((unsigned int)dt + 2), // 8 + dt + //if not, jump absolute to where index is written to memory + I_BXI(3) // 4 + }; + // write io and jump back another 12 + 4 + 12 + 4 + + size_t load_addr = 0; + size_t size = sizeof(stereo)/sizeof(ulp_insn_t); + ulp_process_macros_and_load(load_addr, stereo, &size); + // this is how to get the opcodes + // for(int i = 0; i < size; i++) + // Serial.println(RTC_SLOW_MEM[i], HEX); + + //create DAC opcode tables + switch(activeDACs){ + case 1: + for(int i = 0; i < 256; i++) + { + RTC_SLOW_MEM[dacTableStart1 + i * 2] = create_I_WR_REG(RTC_IO_PAD_DAC1_REG,19,26,i); //dac1: 0x1D4C0121 | (i << 10) + RTC_SLOW_MEM[dacTableStart1 + 1 + i * 2] = create_I_BXI(retAddress1); // 0x80000000 + retAddress1 * 4 + RTC_SLOW_MEM[dacTableStart2 + i * 2] = create_I_WR_REG(RTC_IO_PAD_DAC1_REG,19,26,i); //dac2: 0x1D4C0122 | (i << 10) + RTC_SLOW_MEM[dacTableStart2 + 1 + i * 2] = create_I_BXI(retAddress2); // 0x80000000 + retAddress2 * 4 + } + break; + case 2: + for(int i = 0; i < 256; i++) + { + RTC_SLOW_MEM[dacTableStart1 + i * 2] = create_I_WR_REG(RTC_IO_PAD_DAC2_REG,19,26,i); //dac1: 0x1D4C0121 | (i << 10) + RTC_SLOW_MEM[dacTableStart1 + 1 + i * 2] = create_I_BXI(retAddress1); // 0x80000000 + retAddress1 * 4 + RTC_SLOW_MEM[dacTableStart2 + i * 2] = create_I_WR_REG(RTC_IO_PAD_DAC2_REG,19,26,i); //dac2: 0x1D4C0122 | (i << 10) + RTC_SLOW_MEM[dacTableStart2 + 1 + i * 2] = create_I_BXI(retAddress2); // 0x80000000 + retAddress2 * 4 + } + break; + case 3: + for(int i = 0; i < 256; i++) + { + RTC_SLOW_MEM[dacTableStart1 + i * 2] = create_I_WR_REG(RTC_IO_PAD_DAC1_REG,19,26,i); //dac1: 0x1D4C0121 | (i << 10) + RTC_SLOW_MEM[dacTableStart1 + 1 + i * 2] = create_I_BXI(retAddress1); // 0x80000000 + retAddress1 * 4 + RTC_SLOW_MEM[dacTableStart2 + i * 2] = create_I_WR_REG(RTC_IO_PAD_DAC1_REG,19,26,i); //dac2: 0x1D4C0122 | (i << 10) + RTC_SLOW_MEM[dacTableStart2 + 1 + i * 2] = create_I_BXI(retAddress2); // 0x80000000 + retAddress2 * 4 + } + break; + } + + //set all samples to 128 (silence) + for(int i = 0; i < totalSampleWords; i++) + RTC_SLOW_MEM[bufferStart + i] = 0x8080; + + //start + RTC_SLOW_MEM[indexAddress] = 0; + ulp_run(0); + + //wait until ULP starts using samples and the index of output sample advances + while(RTC_SLOW_MEM[indexAddress] == 0) + delay(1); + + return true; +} + +bool AudioOutputULP::ConsumeSample(int16_t sample[2]) +{ + int16_t ms[2]; + ms[0] = sample[0]; + ms[1] = sample[1]; + MakeSampleStereo16( ms ); + + // TODO: needs improvement (counting is different here with respect to ULP code) + int currentSample = RTC_SLOW_MEM[indexAddress] & 0xffff; + int currentWord = currentSample >> 1; + + for (int i=0; i<2; i++) { + ms[i] = ((ms[i] >> 8) + 128) & 0xff; + } + if(!stereoOutput) // mix both channels + ms[0] = (uint16_t)(( (uint32_t)((int32_t)(ms[0]) + (int32_t)(ms[1])) >> 1 ) & 0xff); + + if(waitingOddSample){ // always true for stereo because samples are consumed in pairs + if(lastFilledWord != currentWord) // accept sample if writing index lastFilledWord has not reached index of output sample + { + unsigned int w = ms[0]; + if(stereoOutput){ + w |= ms[1] << 8; + } else { + w |= bufferedOddSample << 8; + bufferedOddSample = 128; + waitingOddSample = false; + } + RTC_SLOW_MEM[bufferStart + lastFilledWord] = w; + lastFilledWord++; + if(lastFilledWord == totalSampleWords) + lastFilledWord = 0; + return true; + } else { + return false; + } + } else { + bufferedOddSample = ms[0]; + waitingOddSample = true; + return true; + } +} + + +bool AudioOutputULP::stop() +{ + audioLogger->printf_P(PSTR("\n\n\nstop\n\n\n")); + const ulp_insn_t stopulp[] = { + //stop the timer + I_END(), + //end the program + I_HALT()}; + + size_t load_addr = 0; + size_t size = sizeof(stopulp)/sizeof(ulp_insn_t); + ulp_process_macros_and_load(load_addr, stopulp, &size); + + //start + ulp_run(0); + + if(activeDACs & 1){ + dac_output_voltage(DAC_CHANNEL_1, 128); + } + if(activeDACs & 2){ + dac_output_voltage(DAC_CHANNEL_2, 128); + } + + return true; +} + +#endif diff --git a/src/AudioOutputULP.h b/src/AudioOutputULP.h new file mode 100644 index 0000000..4fc0e95 --- /dev/null +++ b/src/AudioOutputULP.h @@ -0,0 +1,63 @@ +/* + AudioOutputULP + Outputs to ESP32 DAC through the ULP, freeing I2S for other uses + + v 0.0.1 (2020-10-01) + + Copyright (C) 2020 Martin Laclaustra, based on bitluni's code + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +// Connect left channel on pin 25 +// Connect right channel on pin 26 + +#ifndef _AUDIOOUTPUTULP_H +#define _AUDIOOUTPUTULP_H + +#include "AudioOutput.h" + +#ifdef ESP32 + +class AudioOutputULP : public AudioOutput +{ + public: + AudioOutputULP(int argActiveDACs=3) {if(argActiveDACs<1||argActiveDACs>2)argActiveDACs=3;activeDACs=argActiveDACs;stereoOutput=activeDACs==3;}; + ~AudioOutputULP() {}; + virtual bool begin() override; + virtual bool ConsumeSample(int16_t sample[2]) override; + virtual bool stop() override; + enum : int { DAC1 = 1, DAC2 = 2 }; + private: + int lastFilledWord = 0; + uint8_t bufferedOddSample = 128; + bool waitingOddSample = true; // must be set to false for mono output + int activeDACs = 3; // 1:DAC1; 2:DAC2; 3:both; + bool stereoOutput = true; + const int opcodeCount = 18; + const uint32_t dacTableStart1 = 2048 - 512; + const uint32_t dacTableStart2 = dacTableStart1 - 512; + uint32_t totalSampleWords = 2048 - 512 - 512 - (opcodeCount + 1); // add 512 for mono + const int totalSamples = totalSampleWords * 2; + const uint32_t indexAddress = opcodeCount; + const uint32_t bufferStart = indexAddress + 1; +}; + +#else + +#error Only the ESP32 supports ULP audio output + +#endif + +#endif