PokittoLib with changes to lcd refresh etc.
Fork of Pokitto by
This is a fork by user @Spinal, and is used in Pokittris for testing. Do not import this to your own program.
Diff: POKITTO_HW/HWSound.cpp
- Revision:
- 0:e8b8f36b4505
- Child:
- 2:968589ca3484
diff -r 000000000000 -r e8b8f36b4505 POKITTO_HW/HWSound.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/POKITTO_HW/HWSound.cpp Mon Sep 18 11:47:51 2017 +0000 @@ -0,0 +1,371 @@ +/**************************************************************************/ +/*! + @file HWSound.cpp + @author Jonne Valola + + @section LICENSE + + Software License Agreement (BSD License) + + Copyright (c) 2016, Jonne Valola + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. Neither the name of the copyright holders nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +/**************************************************************************/ + +#include "mbed.h" +#include "HWSound.h" +//#include "MCP4018.h" +#include "SoftwareI2C.h" +#include "Pokitto_settings.h" +#include "PokittoDisk.h" +#include "PokittoGlobs.h" +#include "Synth.h" + + + +using namespace Pokitto; + +/** Sound Variables **/ +#if (POK_STREAMING_MUSIC > 0) + unsigned char buffers[4][BUFFER_SIZE]; + volatile int currentBuffer = 0, oldBuffer = 0; + volatile int bufindex = 0, vol=1; + volatile unsigned char * currentPtr; + volatile unsigned char * endPtr; + int8_t streamvol=3; + uint32_t streamcounter=0; + uint8_t streamstep=0; +#endif + +#if POK_ENABLE_SOUND > 0 + pwmout_t Pokitto::audiopwm; // this way (instead of PwmOut class) pwm doesn't start screaming until it is initialized ! + Ticker Pokitto::audio; + +using namespace Pokitto; + +/** stream output and status */ +uint8_t Pokitto::streambyte,Pokitto::streamon; + +uint8_t soundbuf[256], soundbufindex=0, Pokitto::HWvolume=0; +bool volpotError=false; //test for broken MCP4018 + +uint16_t soundbyte; + + +#if POK_USE_DAC > 0 +#if POK_BOARDREV == 1 + /** 2-layer board rev 1.3 **/ + DigitalOut dac0(P1_6); + DigitalOut dac1(P1_0); + DigitalOut dac2(P1_16); + DigitalOut dac3(P0_19); + DigitalOut dac4(P0_17); + DigitalOut dac5(P1_12); + DigitalOut dac6(P1_15); + DigitalOut dac7(P1_8); +#else + /** 4-layer board rev 2.1 **/ + DigitalOut dac0(P1_28); + DigitalOut dac1(P1_29); + DigitalOut dac2(P1_30); + DigitalOut dac3(P1_31); + /* has daniel made a mistake ?*/ + DigitalOut dac4(P2_20); + DigitalOut dac5(P2_21); + DigitalOut dac6(P2_22); + DigitalOut dac7(P2_23); + + DigitalOut amp(P1_17); + +#endif // POK_BOARDREV +#endif // POK_USE_DAC + +#if POK_BOARDREV == 2 +//MCP4018 volpot(P0_5,P0_4); + +void initHWvolumecontrol() { + HWvolume=0; + volpotError=true; + //if (volpot.put(HWvolume)) volpotError=true; //try if MCP4018 answers + setHWvolume(VOLUME_STARTUP); +} + +int Pokitto::setHWvolume(uint8_t v) { + HWvolume = 0x7F&v; + //if (!volpotError) return volpot.put(HWvolume); //use normal I2C + /* fallback method for broken MCP4018 */ + SoftwareI2C swvolpot(P0_4, P0_5); //swapped SDA,SCL + swvolpot.write(0x5e,HWvolume); +} + +uint8_t Pokitto::getHWvolume() { + return HWvolume; +} + +void Pokitto::changeHWvolume(int8_t v) { + int temp = HWvolume + v; + if (temp < 0) temp = 0; //prevent volume "looparound" than can make a massive crack + if (temp > 127) temp = 127; + setHWvolume(temp); +} + + uint8_t Pokitto::ampIsOn() { + return amp; + } + + void Pokitto::ampEnable(uint8_t v) { + if (v>1) v=1; // limit against funny values + amp=v; + } +#endif // POK_BOARDREV == 2 + +void Pokitto::dac_write(uint8_t value) { + #if POK_USE_DAC > 0 + #if POK_BOARDREV == 1 // was 1 + if (value & 1) SET_DAC0 else CLR_DAC0; + value >>= 1; + if (value & 1) SET_DAC1 else CLR_DAC1; + value >>= 1; + if (value & 1) SET_DAC2 else CLR_DAC2; + value >>= 1; + if (value & 1) SET_DAC3 else CLR_DAC3; + value >>= 1; + if (value & 1) SET_DAC4 else CLR_DAC4; + value >>= 1; + if (value & 1) SET_DAC5 else CLR_DAC5; + value >>= 1; + if (value & 1) SET_DAC6 else CLR_DAC6; + value >>= 1; + if (value & 1) SET_DAC7 else CLR_DAC7; + #else + //uint32_t val; + //val = value<<28; //lower 4 bits go higher - because port mask is used, no AND is needed to clear bits + //val += value<<(15-4); //higher 4 bits go lower. No need to shift by 15 because bits are in the higher nibble + /* daniel has made a mistake with ports */ + //val = ((value&0x70)<<(28-4)); //higher 4 bits go higher - because port mask is used, no AND is needed to clear bits + //val += value<<(15); //lower 4 bits go lower. No need to shift by 15 because bits are in the higher nibble + //SET_MASK_DAC; + //LPC_GPIO_PORT->MPIN[1] = val; // write bits to port + //CLR_MASK_DAC; + /* fixed here */ + /*val=value; + SET_MASK_DAC_LO; + LPC_GPIO_PORT->MPIN[1] = val<<28; // write lower 4 bits to port + CLR_MASK_DAC_LO; + SET_MASK_DAC_HI; + LPC_GPIO_PORT->MPIN[2] = val<<(20-4); // write bits to port + CLR_MASK_DAC_HI; */ + if (value & 1) SET_DAC0 else CLR_DAC0; + value >>= 1; + if (value & 1) SET_DAC1 else CLR_DAC1; + value >>= 1; + if (value & 1) SET_DAC2 else CLR_DAC2; + value >>= 1; + if (value & 1) SET_DAC3 else CLR_DAC3; + value >>= 1; + if (value & 1) SET_DAC4 else CLR_DAC4; + value >>= 1; + if (value & 1) SET_DAC5 else CLR_DAC5; + value >>= 1; + if (value & 1) SET_DAC6 else CLR_DAC6; + value >>= 1; + if (value & 1) SET_DAC7 else CLR_DAC7; + //CLR_MASK_DAC; + #endif // BOARDREV + #endif +} + +/** SOUND INIT **/ +void Pokitto::soundInit() { + + pwmout_init(&audiopwm,POK_AUD_PIN); + pwmout_period_us(&audiopwm,POK_AUD_PWM_US); //was 31us + pwmout_write(&audiopwm,0.1f); + + #if POK_GBSOUND > 0 + /** GAMEBUINO SOUND **/ + audio.attach_us(&audio_IRQ, 1000000/(POK_AUD_FREQ>>0)); + #else + /** NOT GAMEBUINO SOUND **/ + audio.attach_us(&pokSoundIRQ, 1000000/(POK_AUD_FREQ>>0)); + #endif // POK_GAMEBUINO_SUPPORT + + //emptySong(); + //emptyOscillators(); + //emptyBlocks(); + //emptyPatches(); + #ifdef TEST_SOUND + testOsc(); + #endif // TEST_SOUND + #if POK_BOARDREV == 2 + initHWvolumecontrol(); + #endif + +} + + +uint8_t Pokitto::streamPaused() { + return !streamon; +} + +void Pokitto::pauseStream() { + streamon=0; +} + +void Pokitto::playStream() { + streamon=1; +} + + +void pokPauseStream() { + streamon=0; +} + +void pokPlayStream() { + streamon=1; +} + +void pokSoundIRQ() { + uint8_t output=0; + #ifndef POK_SIM + pwmout_t* obj = &audiopwm; + #endif + #if POK_STREAMING_MUSIC > 0 + #if POK_STREAMFREQ_HALVE + streamstep = 1-streamstep; + #else + streamstep = 1; + #endif // POK_STREAMFREQ_HALVE + streamstep &= streamon; // streamon is used to toggle SD music streaming on and off + if (streamstep) { + output = (*currentPtr++); + if(streamvol && streamon) { + output >>= 3-streamvol; + streambyte = output; + } else { + streambyte = 0; // duty cycle + output = 0; + } + if (currentPtr >= endPtr) + { + currentBuffer++; + if (currentBuffer==4) currentBuffer=0; + currentPtr = buffers[currentBuffer]; + endPtr = currentPtr + BUFFER_SIZE; + } + } + #endif // POK_STREAMING_MUSIC + + /** DO ADDITIONAL SOUND PROCESSING (NOT STREAM) OF SOUND HERE **/ + + #if POK_ENABLE_SYNTH + /** if song is being played from sd **/ + if (playing) { + notetick++; + updatePlaybackSD(playerpos&7); + } + /** oscillators update **/ + osc1.count += osc1.cinc + (osc1.pitchbend >> 4); // counts to 65535 and overflows to zero WAS 8 ! + osc2.count += osc2.cinc + (osc2.pitchbend >> 4); // counts to 65535 and overflows to zero + osc3.count += osc3.cinc + (osc3.pitchbend >> 4); // counts to 65535 and overflows to zero + Marr[tick](); // call mixing function + --tick; + + /** mixing oscillator output **/ + + uint16_t op = (uint16_t) ((osc1.output)*(osc1.vol>>8))>>9;// >> 2 osc1.vol Marr; + op += (uint16_t) ((osc2.output)*(osc2.vol>>8))>>9;// >> 2 osc1.vol Marr; + op += (uint16_t) ((osc3.output)*(osc3.vol>>8))>>9;// >> 2 osc1.vol Marr; + output = (uint8_t) op; + + #endif // POK_ENABLE_SYNTH + + #ifndef POK_SIM + /** HARDWARE **/ + #if POK_ENABLE_SOUND > 0 + #if POK_STREAMING_MUSIC > 0 + /** sound is enabled, streaming is enabled */ + #if POK_STREAM_TO_DAC > 0 + /** stream goes to DAC */ + #if POK_USE_DAC > 0 + if (streamstep) dac_write((uint8_t)streambyte); // duty cycle + #endif // POK_USE_DAC + #else + /** stream goes to PWM */ + if (streamstep) { + pwmout_write(&audiopwm,(float)streambyte/(float)255); + //uint32_t t_on = (uint32_t)(((obj->pwm->MATCHREL0)*streambyte)>>8); //cut out float + //obj->pwm->MATCHREL1 = t_on; + //dac_write((uint8_t)streambyte); // duty cycle + } + #endif // POK_STREAM_TO_DAC + #endif // POK_STREAMING_MUSIC + #if POK_STREAM_TO_DAC > 0 + /** synth goes to PWM */ + pwmout_write(&audiopwm,(float)output/(float)255); + //uint32_t t_on = (uint32_t)(((obj->pwm->MATCHREL0)*output)>>8); //cut out float + //obj->pwm->MATCHREL1 = t_on; + #else + dac_write((uint8_t)output); + #endif // decide where synth is output + soundbyte = (output+streambyte)>>1; + soundbuf[soundbufindex++]=soundbyte; + #endif //POK_ENABLE_SOUND + #endif // HARDWARE +} + + +void Pokitto::updateSDAudioStream() { + if (streamPaused()) return; + + #if POK_STREAMING_MUSIC > 0 + if (oldBuffer != currentBuffer) { + if (currentBuffer==0) fileReadBytes(&buffers[3][0],BUFFER_SIZE); + else if (currentBuffer==1) fileReadBytes(&buffers[0][0],BUFFER_SIZE); + else if (currentBuffer==2) fileReadBytes(&buffers[1][0],BUFFER_SIZE); + else fileReadBytes(&buffers[2][0],BUFFER_SIZE); + oldBuffer = currentBuffer; + streamcounter += BUFFER_SIZE; + } else return; + + #ifndef POK_SIM + if ( streamcounter > fs.fsize - (BUFFER_SIZE*6)) { + #else + if ( streamcounter > getFileLength() - (BUFFER_SIZE*6)) { + #endif + streamcounter=0; + #if POK_STREAM_LOOP + fileRewind(); + #else + pokPauseStream(); + #endif + } + #endif +} + + +#endif // POK_ENABLE_SOUND + +