AVR Freaks

I didn't realise C would automatically infer a 1 or 0, excellent tip. 

That squareRootRounded function was nicked from elsewhere, you're right though it should be a 32 bit input and a 16 bit return.

It's all been tested and working well. As stated the precision isn't perfect but it's a trade-off for speed or I'd be using floating points.

The CPU is running at 10MHz after prescaler, this code runs at 10Hz so one pass has 1MHz of processing available. It's the most expensive operation in the application but the lesser processing of the 1MHz it takes up the better.

Modified with improvements

static uint16_t squareRootRounded(uint16_t op) {
    
    uint32_t res = 0;
    uint16_t one = 1u << 14; // The second-to-top bit is set: use 1u << 14 for uint16_t type; use 1uL<<30 for uint32_t type

    // "one" starts at the highest power of four <= than the argument.
    while (one > op) {
        one >>= 2;
    }

    while (one != 0) {
        if (op >= res + one) {
            op -= res + one;
            res +=  2 * one;
        }
        res >>= 1;
        one >>= 2;
    }

    /* Do arithmetic rounding to nearest integer */
    if (op > res) {
        res++;
    }

    return res;
}

void MOTION_Task (void) {
    
    if (! TIMER_INT_FLAG) {
        return;
    }
    
    // save result
    currentBuffer->value = TIMER_CAPTURE_VALUE; // timer will clear int flag automatically

    // move buffer
    if (currentBuffer == &buffer[MOTION_BUFFER_COUNT-1]) {
        currentBuffer = &buffer[0];
        motion.ready = 1;
    } else {
        currentBuffer++;
        if (!motion.ready) {
            return;
        }
    }
    
    uint8_t i;
    uint8_t reads = 0;

    // mean
    uint32_t mean = 0;
    for (i=0; i < MOTION_BUFFER_COUNT; ++i) {
        if (buffer[i].value) {
            mean += buffer[i].value;
            ++reads;  
        }
    }
    mean /= reads;
    
    // deltas
    uint32_t delta = 0;
    for (i=0; i < MOTION_BUFFER_COUNT; ++i) {
        if (buffer[i].value) {
            uint16_t x = buffer[i].value - mean; // mean can't be greater than uint16_t at this point
            delta += x*x;
        }
    }
    delta /= reads;
    
    // standard deviation
    uint16_t sd = squareRootRounded(delta);
    
    // mark outliers
    sd *= 2;
    for (i=0; i < MOTION_BUFFER_COUNT; ++i) {
        buffer[i].outlier = !buffer[i].value || buffer[i].value < (mean - sd) || buffer[i].value > (mean + sd);
    }
    
    // recompute mean and sd without outliers
    mean = 0;
    reads = 0;
    for (i=0; i < MOTION_BUFFER_COUNT; ++i) {
        if (! buffer[i].outlier) {
            mean += buffer[i].value;
            ++reads;  
        }
    }
    motion.mean = mean / reads;
    
    // deltas
    delta = 0;
    for (i=0; i < MOTION_BUFFER_COUNT; ++i) {
        if (! buffer[i].outlier) {
            uint16_t x = buffer[i].value - motion.mean;
            delta += x*x;
        }
    }
    
    delta /= reads;
     
    // standard deviation
    sd = squareRootRounded(delta);
    
    // co-efficient of variation
    uint8_t cov = motion.mean? ((sd*100) / motion.mean) : 0;

    //outcome
    motion.stable = cov < MOTION_STABILITY_MAX_COV;
}