リスト1

/* */

/* List 1 */

/* DC auto offset --- C source */

/* copyright (C) 2007 thinking-j, All Rights Reserved. */

/* */

#define OFFSET_MAX_COUNT 96 #define OFFSET_THRESHOLD 8

#define SENSEOR_MAX_COUNT 5

struct cyclic_array {

int index;

int data[OFFSET_MAX_COUNT];

int data_count;

};

int ca_input(int data, cyclic_array *array) {

array->data[array->index++] = data;

if (array->data_count < OFFSET_MAX_COUNT) array->data_count++;

if (array->index >= OFFSET_MAX_COUNT)

array->index = 0;

return array->data_count;

}

void ca_initialize(cyclic_array *array) {

int i = 0;

array->index = 0;

array->data_count = 0;

for (i=0; i < OFFSET_MAX_COUNT; i++) array->data[i] = 0;

}

int ca_average(cyclic_array *array) {

int average = 0;

int i = 0;

if (array->data_count == 0) return 0;

while (i < array->data_count)

average += array->data[i++];

return average/i;

}

int ca_n_average(int first, int count, cyclic_array *array) {

int average;

int max;

int i , j;

if (first > array->data_count) return 0;

if (array->data_count < OFFSET_MAX_COUNT)

j = 0;

else

j = first + array->index + 1;

if (j>=OFFSET_MAX_COUNT) j -= OFFSET_MAX_COUNT;

if (count > array->data_count)

max = array->data_count;

else

max = count;

average = 0;

for(i=0; i < max; i++) {

average += array->data[j++];

if (j==OFFSET_MAX_COUNT) j = 0;

}

return average/max;

}

int ca_smoothing(int count, cyclic_array *array) {

int average;

int max;

int i , j;

if (array->data_count < count)

j = 0;

else

j = array->index - count + 1;

if (j < 0) j += OFFSET_MAX_COUNT;

if (count > array->data_count)

max = array->data_count;

else

max = count;

average = 0;

for(i=0; i < max; i++) {

average += array->data[j++];

if (j==OFFSET_MAX_COUNT) j = 0;

}

return average/max;

}

int auto_offset(int data, cyclic_array *array, int old_ave, int max_count, int threshold) {

int average;

int half;

int part_1, part_2;

half = max_count/2;

if (ca_input(data, array) < max_count)

average = ca_average(array);

else { part_1 = ca_n_average(0, half, array);

part_1 = ca_n_average(half, half, array);

if (abs(part_1 - part_2) < threshold)

average = part_2;

else

average = old_ave;

}

return average;

}

int auto_offset3(int data, cyclic_array *array, int old_ave, int max_count, int threshold) {

int average;

int one_third;

int part_1, part_2, part_3;

one_third = max_count/3;

if (ca_input(data, array) < max_count)

average = ca_average(array);

else {

part_1 = ca_n_average(0, one_third, array);

part_2 = ca_n_average(one_third, one_third, array);

part_3 = ca_n_average(2*one_third, one_third, array);

if ((abs(part_1 - part_2) < threshold) && (abs(part_3 - part_2) < threshold))

average = part_3;

else

average = old_ave;

}

return average;

}