File content as of revision 37:633dd1901681:

#include <vector>
#include <numeric>
#include "mbed.h"
#include "MODSERIAL.h"
#include "HIDScope.h"
#include "QEI.h"
#include "FastPWM.h"
#include "refGen.h"
#include "controller.h"
#include "motorConfig.h"
#include "errorFetch.h"
#include "biquadFilter.h"
#include "biquadChain.h"

// ADJUSTABLE PARAMETERS
// controller ticker time interval
const float Ts = 0.1;

// EMG filter parameters
// calibration time
const int calSamples = 100;

volatile float avgEMGvalue = 0;


// high pass
biquadFilter HPbq1(0.9837,-1.9674, 0.9837,1.0000,-1.9769,0.9770);
biquadFilter HPbq2(1.0000, -2.0000, 1.0000, 1.0000, -1.9903, 0.9904);
biquadChain HPbqc(HPbq1, HPbq2);
// low pass
biquadFilter LPbq1(1.0e-5*1.3294, 1.0e-5*2.6587, 1.0e-5*1.3294, 1.0000, -1.7783, 0.7924);
biquadFilter LPbq2(1.0000, 2.0000, 1.0000, 1.0000, -1.8934, 0.9085);
biquadChain LPbqc(LPbq1, LPbq2);

// Controller parameters
const float k_p = 1;
const float k_i = 0; // Still needs a reasonable value
const float k_d = 0; // Again, still need to pick a reasonable value

// Defining motor gear ratio - for BOTH motors as this is the same in the current configuration
const float gearRatio = 131;

// LOGISTICS
// Declaring finite-state-machine states
enum robotStates {KILLED, ACTIVE, CALIBRATING};
volatile robotStates currentState = KILLED;
volatile bool stateChanged = true;

// Declaring a controller ticker and volatile variables to store encoder counts and revs
Ticker controllerTicker;
volatile int m1counts = 0;
volatile int m2counts = 0;
volatile float m1revs = 0.00;
volatile float m2revs = 0.00;

// PWM settings
float pwmPeriod = 1.0/5000.0;
int frequency_pwm = 10000; //10kHz PWM

// Initializing encoder
QEI Encoder1(D12,D13,NC,64, QEI::X4_ENCODING);
QEI Encoder2(D11,D10,NC,64, QEI::X4_ENCODING);
MODSERIAL pc(USBTX, USBRX);
HIDScope scope(5);

// Defining inputs
InterruptIn sw2(SW2);
InterruptIn sw3(SW3);
InterruptIn button1(D2);
InterruptIn button2(D3);
//AnalogIn pot2(A3);
//AnalogIn emg0( A0 );
//AnalogIn emg1( A1 );

// Defining LED outputs to indicate robot state-us
DigitalOut ledG(LED_GREEN);
DigitalOut ledR(LED_RED);
DigitalOut ledB(LED_BLUE);

// Setting up HIDscope
volatile float x;
volatile float y;  
volatile float z; 
volatile float q;
volatile float k;

void sendDataToPc(float data1, float data2, float data3, float data4, float data5){
        // Capture data
        x = data1;
        y = data2;
        z = data3;
        q = data4;
        k = data5;
        scope.set(0, x);   
        scope.set(1, y); 
        scope.set(2, z);
        scope.set(3, q);
        scope.set(4, z);
        scope.send(); // send what's in scope memory to PC
}


// REFERENCE PARAMETERS
int posRevRange = 2; // describes the ends of the position range in complete motor output shaft revolutions in both directions
const float maxAngle = 2*3.14*posRevRange; // max angle in radians


// Function getReferencePosition returns reference angle based on potmeter 1
refGen ref1(A1, maxAngle);
//refGen ref2(A2, maxAngle);

// readEncoder reads counts and revs and logs results to serial window
errorFetch e1(gearRatio, Ts);
//errorFetch e2(gearRatio, Ts);

// Generate a PID controller with the specified values of k_p, k_d and k_i
controller motorController1(k_p, k_d, k_i);
    
// setMotor1 sets the direction and magnitude pins of motor1 depending on the given motorValue. Negative motorValue means clockwise rotation
motorConfig motor1(D4,D5);
motorConfig motor2(D7,D6);

// PROBLEM: if I'm processing the state machine in the endless while loop, how can I adjust robot behavior in the ticker (as it'll keep running)? Do I need to also implement it there? If so, why bother with the while(1) in the main function in the first place?
void measureAndControl(){
    // Read encoders and EMG signal (unnfiltered reference)
    m1counts = Encoder1.getPulses();
    m2counts = Encoder2.getPulses();
    float r1_uf = ref1.getReference();
    //float r2_uf = ref2.getReference();
    pc.printf("In controller ticker \r\n");
    // Finite state machine
    switch(currentState){
            case KILLED:
                {
                // Initialization of KILLED state: cut power to both motors
                if(stateChanged){
                    motor1.kill();
                    //motor2.kill();
                    pc.printf("Killed state \r\n");
                    stateChanged = false;               
                    }

                // Send reference data to pc
                sendDataToPc(r1_uf, r1_uf, r1_uf, r1_uf, r1_uf); // just send the EMG signal value to HIDscope
                
                // Set LED to red
                ledR = 0;
                ledG = 1;
                ledB = 1;
                // need something here to check if "killswitch" has been pressed (?)
                // NOTE: state transition is handled using buttons triggering functions motorConfig::kill() and motorConfig::turnMotorOn
                break;
                }
            case ACTIVE:
                {
                if(stateChanged){
                    pc.printf("Active state \r\n");
                    }
                // Filter reference
                float r1 = HPbqc.applyFilter(r1_uf);
                r1 = fabs(r1);
                r1 = LPbqc.applyFilter(r1);

                //float r2 = HPbqc.applyFilter(r2_uf);
                //r2 = fabs(r2);
                //r2 = LPbqc.applyFilter(r2);

                
                // Compute error
                e1.fetchError(m1counts, r1);
                //e2.fetchError(m2counts, r2);
                
                // Compute motor value using controller and set motor
                float motorValue = motorController1.control(e1.e_pos, e1.e_int, e1.e_der);
                motor1.setMotor(motorValue);
                
                // Send data to HIDscope
                sendDataToPc(r1_uf, r1, e1.e_pos, e1.e_der, motorValue);
                
                // Set LED to blue
                ledR = 1;
                ledG = 1;
                ledB = 0;
                // NOTE: state transition is handled using buttons triggering functions motorConfig::kill() and motorConfig::turnMotorOn
                break;
                }
            case CALIBRATING:
                {
                // NOTE: maybe wrap this whole calibrating thing in a library?
                
               // Do I need to kill motors here?

                
                // Initialization of CALIBRATE state
                static int Ncal = 0;
                std::vector<float> EMGsamples;
                
                if(stateChanged){                                        
                    // Kill motors
                    pc.printf("Calibrate state \r\n");
                    motor1.kill();
                    //motor2.kill();
                    
                    // Clear sample value vector and reset counter variable
                    EMGsamples.clear();
                    Ncal = 0;
                    stateChanged = false;
                    }

                // fill the array with sample data if it is not yet filled
                if(Ncal < calSamples){
                    pc.printf("%.2f \r\n", r1_uf);
                    EMGsamples.push_back(r1_uf);
                    pc.printf("%.2f \r\n", EMGsamples.end());
                    Ncal++;
                    }
                // if array is filled compute the mean value and switch to active state
                else {
                    // Set new avgEMGvalue
                    avgEMGvalue = std::accumulate(EMGsamples.begin(), EMGsamples.end(), 0)/calSamples; // still needs to return this value 
                    
                    pc.printf("Avg emg value is %.2f changed state to active", avgEMGvalue);
                    // State transition logic
                    currentState = ACTIVE;
                    stateChanged = true;
                    Ncal = 0;
                    }
                
                // Set LED to green
                ledR = 1;
                ledG = 0;
                ledB = 1;
                sendDataToPc(r1_uf, r1_uf, r1_uf, r1_uf, r1_uf);
                break;
                }
        }
    
    
    
    }

void rSwitchDirection(){
    ref1.r_direction = !ref1.r_direction;
    pc.printf("Switched reference direction! \r\n");
    }

void killSwitch(){
    currentState = KILLED;
    stateChanged = true;
    }
    
void activateRobot(){
    currentState = ACTIVE;
    stateChanged = true;
    }
    
void calibrateRobot(){
    currentState = CALIBRATING;
    stateChanged = true;
    }

int main()
    {
    pc.baud(115200);
    pc.printf("Main function");
    // Attaching state change functions to buttons;
    sw2.fall(&killSwitch);
    sw3.fall(&activateRobot);
    button1.rise(&calibrateRobot);
    button2.rise(&rSwitchDirection);
    
    controllerTicker.attach(measureAndControl, Ts);
    pc.printf("Encoder ticker attached and baudrate set");    
    }