File content as of revision 30:5d8e6f0fabc1:

#include "mbed.h"
#include "HIDScope.h"
#include "MODSERIAL.h"
#include "arm_math.h"
#include "MAF.h"

HIDScope::HIDScope(int channels) : hid(64,64)
{
    bufferData      = new float[channels]();
    channelCount    = channels;
    scopeData.length = 64;
}

void HIDScope::set(int ch, float val)
{
    bufferData[ch] = val;
}

void HIDScope::set(int ch, int val)
{
    set(ch,(float)val);
}

void HIDScope::set(int ch, bool val)
{
    set(ch,(val ? 1.0f : 0.0f));
}

void HIDScope::set(int ch, double val)
{
    set(ch,(float)val);
}

void HIDScope::send()
{
    for(int ch=0; ch<channelCount; ch++)
        memcpy(&scopeData.data[ch*4], &bufferData[ch], 4); // Copy a 4 byte float to the char array

    // Send non blocking, can be adjusted to blocking (hid.send)
    hid.sendNB(&scopeData);
}

// ****** emg filter shizzle ******

//Define objects
AnalogIn    emgB(PTB0); //Analog input bicep
AnalogIn    emgT(PTB1); //Analog input tricep

float filtered_emgB;
float filtered_emgT;

MODSERIAL pc(USBTX,USBRX);

HIDScope scope(4);//uitgang scherm

arm_biquad_casd_df1_inst_f32 lowpass;
//constants for 50Hz lowpass
float lowpass_const[] = {0.2928920553, 0.5857841107, 0.2928920554, -0, -0.17156822136};//{a0 a1 a2 -b1 -b2} van online calculator
//state values
float lowpass_states[4];

arm_biquad_casd_df1_inst_f32 highpass;
//constants for 10Hz highpass
float highpass_const[] = {0.8005910267, -1.6011820533, 0.8005910267, 1.5610153913, -0.6413487154};//{a0 a1 a2 -b1 -b2}
//state values
float highpass_states[4];


/** Looper function
* functions used for Ticker and Timeout should be of type void <name>(void)
* i.e. no input arguments, no output arguments.
* if you want to change a variable that you use in other places (for example in main)
* you will have to make that variable global in order to be able to reach it both from
* the function called at interrupt time, and in the main function.
* To make a variable global, define it under the includes.
* variables that are changed in the interrupt routine (written to) should be made
* 'volatile' to let the compiler know that those values may change outside the current context.
* i.e.: "volatile uint16_t emg_value;" instead of "uint16_t emg_value"
* in the example below, the variable is not re-used in the main function, and is thus declared
* local in the looper function only.
**/

//BICEP EMG LEZEN
void looperB()
{
    /*variable to store value in*/
    uint16_t emg_valueB;

    float emg_value_f32B;
    /*put raw emg value both in red and in emg_value*/
    emg_valueB = emgB.read_u16(); // read direct ADC result, converted to 16 bit integer (0..2^16 = 0..65536 = 0..3.3V)
    emg_value_f32B = emgB.read();

    //process emg
    arm_biquad_cascade_df1_f32(&highpass, &emg_value_f32B, &filtered_emgB, 1 );
    filtered_emgB = fabs(filtered_emgB);
    arm_biquad_cascade_df1_f32(&lowpass, &filtered_emgB, &filtered_emgB, 1 );

    /*send value to PC. */
    scope.set(0,emg_valueB);     //uint value
    scope.set(1,filtered_emgB);  //processed float
    scope.send();

    MAF::MAF() {}
    float MAF::update(float filtered_emgB) {
        B[0]=filtered_emgB;
        MOVAVG_B=B[0]*0.1+B[1]*0.1+B[2]*0.1+B[3]*0.1+B[4]*0.1+B[5]*0.1+B[7]*0.1+B[8]*0.1+B[9]*0.1
        B[9]=B[8];
        B[8]=B[7];
        B[7]=B[6];
        B[6]=B[5];
        B[5]=B[4];
        B[4]=B[3];
        B[3]=B[2];
        B[2]=B[1];
        B[1]=B[0];

        return MOVAVG_B;
    }
}

void looperT()
{
    /*variable to store value in*/
    uint16_t emg_valueT;

    float emg_value_f32T;
    /*put raw emg value both in red and in emg_value*/
    emg_valueT = emgT.read_u16(); // read direct ADC result, converted to 16 bit integer (0..2^16 = 0..65536 = 0..3.3V)
    emg_value_f32T = emgT.read();

    //process emg
    arm_biquad_cascade_df1_f32(&highpass, &emg_value_f32T, &filtered_emgT, 1 );
    filtered_emgT = fabs(filtered_emgT);
    arm_biquad_cascade_df1_f32(&lowpass, &filtered_emgT, &filtered_emgT, 1 );

    /*send value to PC. */
    scope.set(2,emg_valueT);     //uint value
    scope.set(3,filtered_emgT);  //processed float
    scope.send();

}

int main()
{
    Ticker log_timer;
    //set up filters. Use external array for constants
    arm_biquad_cascade_df1_init_f32(&lowpass,1 , lowpass_const, lowpass_states);
    arm_biquad_cascade_df1_init_f32(&highpass,1 ,highpass_const, highpass_states);

    /**Here you attach the 'void looper(void)' function to the Ticker object
    * The looper() function will be called every 0.01 seconds.
    * Please mind that the parentheses after looper are omitted when using attach.
    */
    log_timer.attach(looperB, 0.005);//??
    log_timer.attach(looperT, 0.005);//??
    while(1) { //Loop
        /*Empty!*/
        /*Everything is handled by the interrupt routine now!*/
    }
}

//filtered_emgB
//filtered_emgT

void Antwoord()
{
    float drempelwaarde=4.99;
    int y;

    if (filtered_emgB > drempelwaarde) {
        y=1;
    } else {
        y=0;
    }

    if (y==1) {
        pc.printf("Motor 1 beweegt\n");
    } else {
        pc.printf("Motor 1 beweegt niet\n");
    }
}
//drempelwaarde.....