File content as of revision 42:3c71f925a47b:

/*
 * main.cpp
 * SpiSequencerSender_test
 *
 * 2016.10.02 UI Controllerに分割
 * 2016.08.20 mbed Rev 121 / mbed-rtos Rev 117で動作確認
 *
 */

#include "mbed.h"
#include "rtos.h"
#include "st7565LCD.h"
#include "PinDetect.h"
#include "RotaryEncoder.h"
#include "AverageAnalogIn.h"

#define UART_TRACE  (1)
#include "Sequence.h"
#include "ST7565_SequencerDisplay.h"

#define TITLE_STR1  ("BaseMachine UI Controller")
#define TITLE_STR2  ("20161007")

#define SEQUENCE_N  (16)
#define SPI1_RATE   (10000000)
#define SPI2_RATE   (1000000)
#define POT_RESOLUTION  (7)     // bit
#define AIN_AVERAGE     (32)    // AnalogInを移動平均する要素数

const int baseNoteNumber = 36;
const int bpmMax = 240;
const int bpmMin = 60;
const int octaveMax = 2;
const int octaveMin = -2;
const int waveShapeMax = 1;
const int UImodeMax = 2;

// Initial Sequence
const int noteOn[SEQUENCE_N] = { 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0 };
const int pitch[SEQUENCE_N]  = {36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36 };
const int tie[SEQUENCE_N]    = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
const int accent[SEQUENCE_N] = { 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 };

// Devices
//
//SPI (PinName mosi, PinName miso, PinName sclk, PinName ssel=NC)
SPI SpiMaster(PA_7, PA_6, PA_5);
DigitalOut SpiMasterCs(PB_6);
InterruptIn stepChangeInterrupt(PC_7);

//ST7565(PinName mosi, PinName sclk, PinName cs, PinName rst, PinName a0);
ST7565 gLCD(PB_15, PB_13, PB_12, PB_2, PB_1);

AverageAnalogIn AinPulseWidth(PC_2, AIN_AVERAGE);
AverageAnalogIn AinCutOff(PB_0, AIN_AVERAGE);
AverageAnalogIn AinResonance(PC_1, AIN_AVERAGE);
AverageAnalogIn AinLevel(PC_0, AIN_AVERAGE);
AverageAnalogIn AinDuration(PA_4, AIN_AVERAGE);
AverageAnalogIn AinDecay(PA_1, AIN_AVERAGE);
AverageAnalogIn AinSustain(PA_0, AIN_AVERAGE);
AverageAnalogIn AinAccentLevel(PC_3, AIN_AVERAGE);

RotaryEncoder RotEncStep(PB_9, PB_8, 0, SEQUENCE_N - 1, 0);
RotaryEncoder RotEncPitch(PB_5, PB_4, 0, Sequence::getMaxPitch() - 1, 0);
RotaryEncoder RotEncBpm(PC_12, PC_10, bpmMin, bpmMax, 120);

PinDetect PinWaveShape(PD_2, PullUp);
PinDetect PinUIMode(PC_11, PullUp);
PinDetect PinOctaveUp(PB_3, PullUp);
PinDetect PinOctaveDown(PA_10, PullUp);
PinDetect PinNoteOnOff(PC_5, PullUp);
PinDetect PinTie(PC_6, PullUp);
PinDetect PinAccent(PC_8, PullUp);
PinDetect PinRunStop(PC_9, PullUp);

// Grobal Variables
//
Sequence sequences[SEQUENCE_N];
ST7565_SequencerDisplay sequencerDisplay(&gLCD, sequences, SEQUENCE_N);

struct OscillatorParam {
    uint8_t waveShape;
    uint8_t pulseWidth;
} oscillatorParam;

struct FilterParam {
    uint8_t cutoff;
    uint8_t resonance;
} filterParam;

struct EnvelopeParam {
    int8_t level;
    int8_t length;
    int8_t duration;
    int8_t decay;
    int8_t sustain;
} envelopeParam;

uint8_t bpm = 120;
uint8_t accentLevel = 127;
   
int currentStep = 0;
int playingStep = 0;
bool isRunning = false;
bool isDirty = true;
int UImode = 0;

volatile bool isStepChanged = false;
volatile uint8_t pinFlag = 0x00;

enum PinBit {
    bWaveShape  = 0x01,
    bUIMode     = 0x02,
    bOctaveUp   = 0x04,
    bOctaveDown = 0x08,
    bNoteOnOff  = 0x10,
    bTie        = 0x20,
    bAccent     = 0x40,
    bRunStop    = 0x80
};

//------------------------------------------------------------------------
// InterruptIn ISR
//------------------------------------------------------------------------
void updateStep()
{
    isStepChanged = true;
}

//------------------------------------------------------------------------
// PinDetect ISR
//------------------------------------------------------------------------
void swWaveShapePressed()
{
    pinFlag |= bWaveShape;
}

void swUIModePressed()
{
    pinFlag |= bUIMode;
}

void swOctaveUpPressed()
{
    pinFlag |= bOctaveUp;
}

void swOctaveDownPressed()
{
    pinFlag |= bOctaveDown;
}

void swNoteOnOffPressed()
{
    pinFlag |= bNoteOnOff;
}

void swTiePressed()
{
    pinFlag |= bTie;
}

void swAccentPressed()
{
    pinFlag |= bAccent;
}

void swRunStopPressed()
{
    pinFlag |= bRunStop;
}

//------------------------------------------------------------------------
// Functions
//------------------------------------------------------------------------
void pollingPots()
{
    oscillatorParam.pulseWidth = AinPulseWidth.read_u16() >> 8;

    filterParam.cutoff = AinCutOff.read_u16() >> 8;
    filterParam.resonance = AinResonance.read_u16() >> 8;
    
    envelopeParam.level = AinLevel.read_u16() >> 8;
    envelopeParam.duration = AinDuration.read_u16() >> 8;
    envelopeParam.decay = AinDecay.read_u16() >> 8;
    envelopeParam.sustain = AinSustain.read_u16() >> 8;
}

void pollingRotEncs()
{
    int _bpm = RotEncBpm.getVal();
    if (_bpm != bpm) {
        bpm = _bpm;
        sequencerDisplay.setBpm(_bpm);
        isDirty = true;
    }
    
    int _step = RotEncStep.getVal();
    if (_step != currentStep) {
        currentStep = _step;
        // syncronize sequence value & Rotary Encoder's value
        RotEncPitch.setVal(sequences[currentStep].getPitch());
        isDirty = true;
    }
    
    int _pitch = RotEncPitch.getVal();
    if (_pitch != sequences[currentStep].getPitch()) {
        sequences[currentStep].setPitch(_pitch);
        isDirty = true;
    }
}

void pollingPins()
{
    if (pinFlag & bWaveShape) {
        #if (UART_TRACE)
        printf("PinWaveShape Pushed\r\n");
        #endif
        uint8_t _waveShape = oscillatorParam.waveShape;
        _waveShape++;
        if (_waveShape > waveShapeMax) {
            _waveShape = 0;
        }
        oscillatorParam.waveShape = _waveShape;
        sequencerDisplay.setWaveShape(_waveShape);
        pinFlag &= ~bWaveShape;
        isDirty = true;
    }
    
    if (pinFlag & bUIMode) {
        #if (UART_TRACE)
        printf("PinUIMode Pushed\r\n");
        #endif
        UImode++;
        if (UImode > UImodeMax) {
            UImode = 0;
        }
        pinFlag &= ~bUIMode;
        isDirty = true;
    }
    
    if (pinFlag & bOctaveUp) {
        #if (UART_TRACE)
        printf("PinOctaveUp Pushed\r\n");
        #endif
        if (sequencerDisplay.getOctave() < octaveMax ) {
            sequencerDisplay.setOctave(sequencerDisplay.getOctave() + 1);
            isDirty = true;
        }
        pinFlag &= ~bOctaveUp;
    }

    if (pinFlag & bOctaveDown) {
        #if (UART_TRACE)
        printf("PinOctaveDown Pushed\r\n");
        #endif
        if (sequencerDisplay.getOctave () > octaveMin) {        
            sequencerDisplay.setOctave(sequencerDisplay.getOctave() - 1);
            isDirty = true;
        }
        pinFlag &= ~bOctaveDown;
    }
    
    if (pinFlag & bNoteOnOff) {
        #if (UART_TRACE)
        printf("PinNoteOnOff Pushed\r\n");
        #endif
        sequences[currentStep].setNoteOn(!sequences[currentStep].isNoteOn());
        pinFlag &= ~bNoteOnOff;
        isDirty = true;
    }
    
    if (pinFlag & bTie) {
        #if (UART_TRACE)
        printf("PinTie Pushed\r\n");
        #endif
        sequences[currentStep].setTie(!sequences[currentStep].isTie());
        pinFlag &= ~bTie;
        isDirty = true;
    }
    
    if (pinFlag & bAccent) {
        #if (UART_TRACE)
        printf("PinAccent Pushed\r\n");
        #endif
        sequences[currentStep].setAccent(!sequences[currentStep].isAccent());
        pinFlag &= ~bAccent;
        isDirty = true;
    }
    
    if (pinFlag & bRunStop) {
        #if (UART_TRACE)
        printf("PinRunStop Pushed\r\n");
        #endif
        if (isRunning) {
            isRunning = false;
        } else {
            isRunning = true;
        }
        pinFlag &= ~bRunStop;
        isDirty = true;
    }
}

void dumpToLCD00()
{
    char buff[64];
    int col = 0;
    
    gLCD.clear();

    sprintf(buff, "Run:%d BPM:%03d", isRunning, bpm);
    gLCD.drawstring(0, col++, buff);

    sprintf(buff, "Stp:%02d Nto:%d Pch:%02d",
        currentStep, sequences[currentStep].isNoteOn(), sequences[currentStep].getPitch());
    gLCD.drawstring(0, col++, buff);
    
    sprintf(buff, "Oct:%-2d Tie:%d Acc:%d", 
        sequencerDisplay.getOctave(), sequences[currentStep].isTie(),sequences[currentStep].isAccent());
    gLCD.drawstring(0, col++, buff);

    sprintf(buff, "Wsp:%d Mod:%d pStp:%d", oscillatorParam.waveShape, UImode, playingStep);
    gLCD.drawstring(0, col++, buff);
    
    sprintf(buff, "PW :%4d   CO :%4d", oscillatorParam.pulseWidth, filterParam.cutoff);
    gLCD.drawstring(0, col++, buff);
    sprintf(buff, "RSO:%4d   ACL:%4d", filterParam.resonance, accentLevel);
    gLCD.drawstring(0, col++, buff);
    sprintf(buff, "LVL:%4d   DUR:%4d", envelopeParam.level, envelopeParam.duration);
    gLCD.drawstring(0, col++, buff);
    sprintf(buff, "DCY:%4d   SUS:%4d", envelopeParam.decay, envelopeParam.sustain);
    gLCD.drawstring(0, col++, buff);
    
    gLCD.display();
}

void dumpToLCD01()
{
    static int errCutoff = 0;
    static int errDuration = 0;
    static int errDecay = 0;
    static int errSustain = 0;
    static int errResonace = 0;
    static int errLevel = 0;
    static int errPulseWidth = 0;
    static int errAccentLevel = 0;

    uint8_t v;
    char buff[64];

    v = AinCutOff.read_u16() >> (16 - POT_RESOLUTION);
    if (v != filterParam.cutoff) {
        errCutoff++;
        filterParam.cutoff = v;
    }
    v = AinDuration.read_u16() >> (16 - POT_RESOLUTION);
    if (v != envelopeParam.duration) {
        errDuration++;
        envelopeParam.duration = v;
    }        
    v = AinDecay.read_u16() >> (16 - POT_RESOLUTION);
    if (v != envelopeParam.decay) {
        errDecay++;
        envelopeParam.decay = v;
    }
    v = AinSustain.read_u16() >> (16 - POT_RESOLUTION);
    if (v != envelopeParam.sustain) {
        errSustain++;
        envelopeParam.sustain = v;
    }
    
    v = AinResonance.read_u16() >> (16 - POT_RESOLUTION);
    if (v != filterParam.resonance) {
        errResonace++;
        filterParam.resonance = v;
    }
    v = AinLevel.read_u16() >> (16 - POT_RESOLUTION);
    if (v != envelopeParam.level) {
        errLevel++;
        envelopeParam.level = v;
    }
    v = AinPulseWidth.read_u16() >> (16 - POT_RESOLUTION);
    if (v != oscillatorParam.pulseWidth) {
        errPulseWidth++;
        oscillatorParam.pulseWidth = v;
    }
    v = AinAccentLevel.read_u16() >> (16 - POT_RESOLUTION);
    if (v != accentLevel) {
        errAccentLevel++;
        accentLevel = v;
    }
    
    gLCD.clear();
    
    sprintf(buff, "Cutoff     %3d %5d", filterParam.cutoff, errCutoff);
    gLCD.drawstring(0, 0, buff);
    sprintf(buff, "Duration   %3d %5d", envelopeParam.duration, errDuration);
    gLCD.drawstring(0, 1, buff);
    sprintf(buff, "Decay      %3d %5d", envelopeParam.decay, errDecay);
    gLCD.drawstring(0, 2, buff);
    sprintf(buff, "Sustain    %3d %5d", envelopeParam.sustain, errSustain);
    gLCD.drawstring(0, 3, buff);
    sprintf(buff, "Resonance  %3d %5d", filterParam.resonance, errResonace);
    gLCD.drawstring(0, 4, buff);
    sprintf(buff, "Level      %3d %5d", envelopeParam.level, errLevel);
    gLCD.drawstring(0, 5, buff);
    sprintf(buff, "PulseWidth %3d %5d", oscillatorParam.pulseWidth, errPulseWidth);
    gLCD.drawstring(0, 6, buff);
    sprintf(buff, "AccentLvl  %3d %5d", accentLevel, errAccentLevel);
    gLCD.drawstring(0, 7, buff);
    
    gLCD.display();
    Thread::wait(10);
}

//------------------------------------------------------------------------
// Main routine
//------------------------------------------------------------------------
int main()
{
    #if (UART_TRACE)
    printf("*** BaseMachine UI Controller ***\r\n");
    #endif
    
    //--------------------------------------------------------------------
    // Setup Devices
    //
    gLCD.set_spi_frequency(SPI2_RATE);
    gLCD.begin(0x12);
    gLCD.clear();
    gLCD.drawstring(0, 0, TITLE_STR1);
    gLCD.drawstring(0, 1, TITLE_STR2);
    gLCD.display();
    Thread::wait(1000);
    
    RotEncStep.setInterval(100);
    RotEncPitch.setInterval(100);
    RotEncBpm.setInterval(100);
    
    PinWaveShape.attach_asserted(&swWaveShapePressed);
    PinWaveShape.setAssertValue(0);
    PinWaveShape.setSampleFrequency();  
    
    PinUIMode.attach_asserted(&swUIModePressed);
    PinUIMode.setAssertValue(0);
    PinUIMode.setSampleFrequency();
    
    PinOctaveUp.attach_asserted(&swOctaveUpPressed);
    PinOctaveUp.setAssertValue(0);
    PinOctaveUp.setSampleFrequency();  

    PinOctaveDown.attach_asserted(&swOctaveDownPressed);
    PinOctaveDown.setAssertValue(0);
    PinOctaveDown.setSampleFrequency();
    
    PinNoteOnOff.attach_asserted(&swNoteOnOffPressed);
    PinNoteOnOff.setAssertValue(0);
    PinNoteOnOff.setSampleFrequency();  
    
    PinTie.attach_asserted(&swTiePressed);
    PinTie.setAssertValue(0);
    PinTie.setSampleFrequency();  
    
    PinAccent.attach_asserted(&swAccentPressed);
    PinAccent.setAssertValue(0);
    PinAccent.setSampleFrequency();    
    
    PinRunStop.attach_asserted(&swRunStopPressed);
    PinRunStop.setAssertValue(0);
    PinRunStop.setSampleFrequency();
    
    //--------------------------------------------------------------------
    // Initialize SPI Master
    // 
    SpiMasterCs = 1;
    SpiMaster.format(8, 0);
    SpiMaster.frequency(SPI1_RATE);
    
    stepChangeInterrupt.fall(&updateStep);
    
    //--------------------------------------------------------------------
    // Initialize objects
    //
    Sequence::setBaseNoteNumber(baseNoteNumber);
    
    for (int i = 0; i < SEQUENCE_N; i++) {
        Sequence& seq = sequences[i];
        seq.setPitch(pitch[i]);
        seq.setNoteOn(noteOn[i]);
        seq.setTie(tie[i]);
        seq.setAccent(accent[i]);
    }
    RotEncPitch.setVal(sequences[0].getPitch());
    
    //--------------------------------------------------------------------
    // Main loop
    //
    for (;;) {
        // Polling Devices
        if (UImode != 2) {
            pollingPots();
        }
        pollingRotEncs();
        pollingPins();
        
        // Send Params to SPI Slave
        if (isDirty || isStepChanged) {
            SpiMasterCs = 0;
            uint8_t receivedVal = SpiMaster.write(currentStep);
            SpiMasterCs = 1;

            if (isStepChanged) {
                playingStep = receivedVal;
                isStepChanged = false;
                isDirty = true;
            }
        }
        
        // Display
        if (!isRunning) {
            if (isDirty) {
                switch (UImode) {
                case 0:
                    sequencerDisplay.update(SequencerDisplay::stop, currentStep, playingStep);
                    break;
                case 1:
                    dumpToLCD00();
                    break;
                }
                isDirty = false;
            }
            if (UImode == 2) {
                dumpToLCD01();
            }
        } else {
            if (isDirty) {
                sequencerDisplay.update(SequencerDisplay::run, currentStep, playingStep);
                isDirty = false;
            }
        }
    }
}