File content as of revision 3:7e158df628f1:

#include "mbed.h"

#define NELEMS(x)  (sizeof(x) / sizeof((x)[0]))

DigitalOut led_w(p29);
DigitalOut led_e(p28);
DigitalOut led_s(p25);
DigitalOut led_n(p30);
DigitalOut led_c(p27);

AnalogIn senseW(p18);
AnalogIn senseE(p16);
AnalogIn senseS(p19);
AnalogIn senseN(p17);
AnalogIn senseC(p20);

/*
      id1

id2   id4      id0

      id3
*/

int main()
{

    int num_pads = 5;
    int pad_buffer_size = 5;

    float s_w;
    float s_e;
    float s_s;
    float s_n;
    float s_c;

    int avg_w;
    int avg_e;
    int avg_s;
    int avg_n;
    int avg_c;
    
    int pad_w_i;
    int pad_e_i;
    int pad_s_i;
    int pad_n_i;
    int pad_c_i;
    
    int* padw_data = new int[pad_buffer_size];
    int* pade_data = new int[pad_buffer_size];
    int* pads_data = new int[pad_buffer_size];
    int* padn_data = new int[pad_buffer_size];
    int* padc_data = new int[pad_buffer_size];

    int newest_w;
    int newest_e;
    int newest_s;
    int newest_n;
    int newest_c;

    int total_w;
    int total_e;
    int total_s;
    int total_n;
    int total_c;

    int outlier_countW;
    int outlier_countE;
    int outlier_countS;
    int outlier_countN;
    int outlier_countC;

    /*
    0 : east
    1 : north
    2 : west
    3 : south
    4 : center
    */

    float* readings = new float[num_pads];
    readings[0] = s_e;
    readings[1] = s_n;
    readings[2] = s_w;
    readings[3] = s_s;
    readings[4] = s_c;
    
    int* averages = new int[num_pads];
    averages[0] = avg_e;
    averages[1] = avg_n;
    averages[2] = avg_w;
    averages[3] = avg_s;
    averages[4] = avg_c;
    
    
    int* indices = new int[num_pads];
    indices[0] = pad_e_i;
    indices[1] = pad_n_i;
    indices[2] = pad_w_i;
    indices[3] = pad_s_i;
    indices[4] = pad_c_i;
    
    int** data_arrs = new int*[num_pads];
    data_arrs[0] = pade_data;
    data_arrs[1] = padn_data;
    data_arrs[2] = padw_data;
    data_arrs[3] = pads_data;
    data_arrs[4] = padc_data;
    
    int* newest_vals = new int[num_pads];
    newest_vals[0] = newest_e;
    newest_vals[1] = newest_n;
    newest_vals[2] = newest_w;
    newest_vals[3] = newest_s;
    newest_vals[4] = newest_c;
    
    int* totals = new int[num_pads];
    totals[0] = total_e;
    totals[1] = total_n;
    totals[2] = total_w;
    totals[3] = total_s;
    totals[4] = total_c;
    
    int* outlier_cts = new int[num_pads];
    outlier_cts[0] = outlier_countE;
    outlier_cts[1] = outlier_countN;
    outlier_cts[2] = outlier_countW;
    outlier_cts[3] = outlier_countS;
    outlier_cts[4] = outlier_countC;

    int i;
    
    //char* out = new char[40];
    
    //int avg;
    while(1) {
        s_w = senseW.read();
        s_e = senseE.read();
        s_n = senseN.read();
        s_s = senseS.read();
        s_c = senseC.read();
        /*
        newest_w = (int) s_w * 100;
        newest_e = (int) s_e * 100;
        newest_n = (int) s_n * 100;
        newest_s = (int) s_s * 100;
        newest_c = (int) s_c * 100;
        */
        
        printf("      %1.2f     \n", s_n);
        printf("%1.2f  %1.2f  %1.2f\n", s_w, s_c, s_e);
        printf ("      %1.2f     \n\n", s_s);
        /*
        for (i=0; i<num_pads; i++) {
            
            if (i==0) {
                readings[0] = senseE.read();
            } else if (i==1) {
                readings[1] = senseN.read();
            } else if (i==2) {
                readings[2] = senseW.read();
            } else if (i==3) {
                readings[3] = senseS.read();
            } else if (i==4) {
                readings[4] = senseC.read();
            }
            
            // maybe << 7 to make this faster?
            newest_vals[i] = readings[i] * 100;
            
            
            
            if (indices[i] < pad_buffer_size - 1) {
                data_arrs[i][indices[i]] = newest_vals[i];
                totals[i] += newest_vals[i];
                indices[i]++;
            } else {
                // get index of last updated value
                indices[i] = (indices[i] + 1) % pad_buffer_size;
                // remove oldest value from the total
                totals[i] -= data_arrs[i][indices[i]];
                // update loc. of oldest value with new value
                data_arrs[i][indices[i]] = newest_vals[i];
                // update total w/ newest value
                totals[i] += newest_vals[i];
            }
            averages[i] = totals[i] / pad_buffer_size;
        }
        printf("    %2i     \n", (int) newest_vals[1]);
        printf("%2i  %2i  %2i\n", (int) newest_vals[2], (int) newest_vals[4], (int) newest_vals[0]);
        printf ("    %2i     \n\n", (int) newest_vals[3]);

        // is newest E value more than 1.5x average?
        if (newest_vals[0] > averages[0] + (averages[0] / 2)) {
            if (outlier_cts[0] == 2) {
                led_e = 1;
            } else {
                outlier_cts[0]++;
            }
        } else {
            outlier_cts[0] = 0;
            led_e = 0;
        }

        if (newest_vals[1] > averages[1] + (averages[1] / 2)) {
            if (outlier_cts[1] == 2) {
                led_n = 1;
            } else {
                outlier_cts[1]++;
            }
        } else {
            outlier_cts[1] = 0;
            led_n = 0;
        }

        if (newest_vals[2] > averages[2] + (averages[2] / 2)) {
            if (outlier_cts[2] == 2) {
                led_w = 1;
            } else {
                outlier_cts[2]++;
            }
        } else {
            outlier_cts[2] = 0;
            led_w = 0;
        }

        if (newest_vals[3] > averages[3] + (averages[3] / 2)) {
            if (outlier_cts[3] == 2) {
                led_s = 1;
            } else {
                outlier_cts[3]++;
            }
        } else {
            outlier_cts[3] = 0;
            led_s = 0;
        }

        if (newest_vals[4] > averages[4] + (averages[4] / 2)) {
            if (outlier_cts[4] == 2) {
                led_c = 1;
            } else {
                outlier_cts[4]++;
            }
        } else {
            outlier_cts[4] = 0;
            led_c = 0;
        }
        */
        wait(1);

        }
    }