正在计算 运行 平均值
Calculating a running average
当平均值应始终介于 0 和 1 之间时，从圆形数组计算的 运行 平均值产生常量 < 0 平均值。
我正在为使用 LED 和光电二极管检测特定类型墨水的 MSP430 设备编写固件。该设备以大约 155us 的速度扫描，扫描仪下的样本速度范围为 0.1m/s 至 3.3m/s。该设备的目标是测试墨水并测量墨水（通过）与测试（未通过）的比率，并在比率介于相应值之间时打开绿色 LED，否则打开红色 LED。我正在使用静态整数数组将连续传递的值和测试值存储到每个数组的相同索引号。在数组的最后一个索引之后，索引被设置回零并覆盖旧值。
GREEN_LED_ON；和类似的定义是我的 MCU 的端口定义并且被验证是正确的。
事件是测试结果。如果检测到墨水，则 event=DETECTED，反之亦然
test 将是 GUI 设置的平均值，但现在它没什么，因为我的函数的这一部分没有工作
通常我会通过随附的 GUI 设置可变平均值，但出于测试目的，我设置平均值 <0 只是为了弄清楚为什么 LED 在错误的时间点亮，我发现我得到的是平均值<0。平均值应始终为 0=
备注：
- 我尝试使用 LED 输出检查代码的各个部分是否正常工作。我注释掉了控制 LED 的平均部分，并通过打开和关闭 LED 验证了 event== 部分是否正常工作。然后我尝试将该代码放入 flag== 部分，并且 LED 也按预期与该部分相对应。
- 我发现数组值有问题。一旦
n > size 它只测试一次而不是等待下一个标志更改。我不能 n>size 因为在我的代码中，n++ 将等于 7，这是越界的
我添加了一段代码以确保不会发生翻转。选择值 8,000 和 30,000 以匹配可能的最慢 运行 速度。
我还更改了数组索引递增的位置，并确保它在数组范围内。
这是更新后的函数：
void display(char event, char test) {
static int size=5;
static int array[6]={0}; //array with number of passes for each n
static int n=0;
static float sum=0;//total number of passes
static float average=0;//average pass rate over n
static int consecpass=0; //consecutive passes
static int consecfail=0; //consecutive fails
static int totalnumberoftests[6]={0}; //total number of tests conducted. Counts the number of passing or failing tests for the nth value
static float counter=1; //used to count the total number of tests
static int flag=0;
if (event == DETECTED)
{
if (flag==0)
{
sum=sum-array[n];
counter=counter-totalnumberoftests[n];
array[n]=0;
totalnumberoftests[n]=consecfail;
sum=sum+array[n];
counter=counter+totalnumberoftests[n];
flag=1;
consecpass++;
n++;
if(n>=size)n=0;
//GREEN_LED_ON;
//RED_LED_OFF;
}else{
consecfail=0;
consecpass++;
//GREEN_LED_ON;
//RED_LED_OFF;
}
} if (event==NOT_DETECTED){
if(flag==1)
{
sum=sum-array[n];
counter=counter-totalnumberoftests[n];
array[n]=consecpass;
totalnumberoftests[n]=consecpass;
sum=sum+array[n];
counter=counter+totalnumberoftests[n];
flag=0;
consecfail++;
n++;
if(n>=size)n=0;
//RED_LED_ON;
//GREEN_LED_OFF;
}else{
consecpass=0;
consecfail++;
//RED_LED_ON;
//GREEN_LED_OFF;
}
}
if (consecpass>8000)
{
sum=sum-array[n];
counter=counter-totalnumberoftests[n];
array[n]=consecpass;
totalnumberoftests[n]=consecpass;
sum=sum+array[n];
counter=counter+totalnumberoftests[n];
consecpass=0;
n++;
if(n>=size)n=0;
}
if(consecfail>30000)
{
sum=sum-array[n];
counter=counter-totalnumberoftests[n];
array[n]=0;
totalnumberoftests[n]=consecfail;
sum=sum+array[n];
counter=counter+totalnumberoftests[n];
consecfail=0;
n++;
if(n>=size)n=0;
}
average=sum/counter;
if(average<.6 && average > .1)
{
GREEN_LED_ON;
RED_LED_OFF;
}else{
GREEN_LED_OFF;
RED_LED_ON;
}
}
if (n >= size) 在标志语句之后声明，以避免我的数组的最终值为 1。这是更改（它在两个 if(flag==) 语句上：
if (flag == 1) {
sum = sum - array[n];
counter = counter - totalnumberoftests[n];
array[n] = consecpass;
totalnumberoftests[n] = consecpass;
sum = sum + array[n];
counter = counter + totalnumberoftests[n];
flag = 0;
consecfail++;
n++;
if (n >= size)
n = 0;
原代码如下：
void display(char event, char test) {
static int size = 6;
static int array[6] = { 0 }; //array with number of passes for each n
static int n = 0;
static float sum = 0;//total number of passes
static float average = 0;//average pass rate over n
static int consecpass = 0; //consecutive passes
static int consecfail = 0; //consecutive fails
static int totalnumberoftests[6] = { 0 }; //total number of tests conducted. Counts the number of passing or failing tests for the nth value
static float counter = 1; //used to count the total number of tests
static int flag = 0;
if (n >= size) {
n = 0;
}
if (event == DETECTED) {
if (flag == 0) {
n++;
sum = sum - array[n];
counter = counter - totalnumberoftests[n];
array[n] = 0;
totalnumberoftests[n] = consecfail;
sum = sum + array[n];
counter = counter + totalnumberoftests[n];
flag = 1;
consecpass++;
} else {
consecfail = 0;
consecpass++;
}
}
if (event == NOT_DETECTED) {
if (flag == 1) {
n++;
sum = sum - array[n];
counter = counter - totalnumberoftests[n];
array[n] = consecpass;
totalnumberoftests[n] = consecpass;
sum = sum + array[n];
counter = counter + totalnumberoftests[n];
flag = 0;
consecfail++;
} else {
consecpass = 0;
consecfail++;
}
}
average = sum / counter;
if (average < 0) {
GREEN_LED_ON;
RED_LED_OFF;
} else {
GREEN_LED_OFF;
RED_LED_ON;
}
}
你有UB。
在顶部你做 if (n>=size) n = 0;。这仍然允许 n 为 size-1
但是，在 访问数组之前，您需要n++ 。这将允许您访问 array[size]，即 UB。
我相信您想将 n++ 移动到 if 部分的底部，在 进行计算之后。而且，您可能希望将两者与 if (++n >= size) n = 0;
结合使用
更新：
I set size=5 and I still get negative numbers. The arrays are both within the boundary now correct?
可能吧。但是，有几件事。
只有 average 需要 [或应该] float。
您有 "parallel" 个数组。我会改用结构。
我已经重复了你的逻辑几次，但我仍然不确定你想要达到什么目的。
因此，我进行了重构以尝试消除任何更多可能的微不足道的错误。
我对计数器的 subtract-and-then-add-back 有点怀疑，尤其是在切换点。这是您可以得到负数的唯一地方。
也许将该函数插入到模拟各种长度的 ink/no 墨水流数据的单元测试程序中会有所帮助。然后你可以断点。这可以 test/verify 你的逻辑，而不必使用实时系统的痛苦（即单元测试程序是一个普通的应用程序，你可以 运行 在你的电脑上）。您可以有条件地编译 in/out LED 代码与 "abort on negative value"，如下所述。
无论如何，这是我的简化，可能有助于澄清[请原谅不必要的样式清理]：
// NOTE: in the long term, an int could wrap to a negative -- adjust this
// as needed
typedef long long ctr;
struct event {
ctr testcount;
ctr passcount;
};
// NOTE: moved this outside function to guarantee all values are zero at start
#define EVENTMAX 6
struct event events[EVENTMAX];
void
display(char event, char test)
{
static int n = 0;
static ctr sum = 0; // total number of passes
static double average; // average pass rate over n
static ctr consecpass = 0; // consecutive passes
static ctr consecfail = 0; // consecutive fails
static ctr testcount = 1; // used to count the total number of tests
static int flag = 0;
struct event *cur;
cur = &events[n];
if (event == DETECTED) {
if (flag == 0) {
sum -= cur->passcount;
testcount -= cur->testcount;
cur->passcount = 0;
cur->testcount = consecfail;
sum += cur->passcount;
testcount += cur->testcount;
flag = 1;
if (++n >= EVENTMAX)
n = 0;
}
else {
consecfail = 0;
}
consecpass++;
}
if (event == NOT_DETECTED) {
if (flag == 1) {
sum -= cur->passcount;
testcount -= cur->testcount;
cur->passcount = consecpass;
cur->testcount = consecpass;
sum += cur->passcount;
testcount += cur->testcount;
flag = 0;
if (++n >= EVENTMAX)
n = 0;
}
else {
consecpass = 0;
}
consecfail++;
}
// add code to abort program if _either_ sum _or_ testcount is negative
// here ...
average = sum;
average /= testcount;
if (average < 0) {
GREEN_LED_ON;
RED_LED_OFF;
}
else {
GREEN_LED_OFF;
RED_LED_ON;
}
}
更新#2：
I found that one of the problems was roll over. I fixed this with an if statement that stores values if they get higher than 8,000 or 30,000. When I'm in debug mode, the values of the arrays look as I expect them to, but I occasionally get negative numbers in sum and counter. How could the wrong indexes be getting subtracted?
即使索引有效，您也可以从 "stale" 条目中减去。我知道您正在尝试实现 RLE。
一个猜测...
您更改了 "current" 条目，但在 ++n 之后，"other" 方可能会在需要前一个条目时获得 "next" 条目。
也就是说，减去 array[0]，应用东西，设置 array[0]，然后递增 n。
对方现在正在减array[1]，需要减array[0]的时候设置array[1].
因此，从逻辑上讲，您可能会遇到 "off by one" 错误。
不知道。
使用单元测试应用程序，您可以为所有内容添加调试 printf。当负值发生时，停止。然后分析日志。单元测试 could/should 测试所有边缘情况。
如果您将（例如）1x10、0x3、1x5、0x20 的序列输入函数，这些应该显示在 arrays/struct 中。存储的条目应与输入序列匹配。
因此，转储数组以验证计数是否符合预期。
什么值达到 8000/30000？
万一有人回到这里，这是我正在使用的代码，我的 运行 平均值运行良好
void display(char event, char test) {
static int size=9; //size of the array
static int array[10]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //array with number of passes for each n
static int n=0; //number for the index in both arrays
static long int sum=0;//total of passes
static double average=0;//rate of passes per tests. The sum of the values in array[n] divided by total tests in totalnumberoftest[n] attay
static int consecpass=0; //consecutive passes
static int consecfail=0; //consecutive fails
static int totalnumberoftests[10]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //total number of tests conducted. Counts the number of passing or failing tests for the nth value
static long int counter=1; //used to count the total number of tests
static int flag=0;//flag used to indicate when the input goes from event==DETECTED to event==NOT_DETECTED
static int lowlimitb=0;// integer value from low limit b in desert for average setting. Value entered should be the positive tests/total tests percentage
sum=sum-(float)array[n]; //subtract the nth value of array from sum
counter=(float)counter-totalnumberoftests[n];
array[n]=0;//set the nth value to zero, because the previous state of event was NOT_DETECTED, meaning there were no positive tests
totalnumberoftests[n]=consecfail; //add the number of negative tests to total tests
sum=sum+(float)array[n]; //add array index n to sum (should be zero)
counter=counter+(float)totalnumberoftests[n]; //counter is the total number of tests. Add totalnumberoftests with the last index n adds the last consecfail to counter
flag=1; //set flag==1 to indicate the last event was DETECTED
consecpass++; //count a pass
consecfail=0;
n++; //set the next index for the arrays
if(n>size)n=0; //if array index is greater than the size of the array, set the index back to zero. This will overwrite the data in array index zero
//GREEN_LED_ON;
//RED_LED_OFF;
}else{ //the last event=DETECT, no need to change array indices
consecpass++;
//GREEN_LED_ON;
//RED_LED_OFF;
}
} if (event==NOT_DETECTED){
if(flag==1) //flag gets set to 1 in event==DETECTED
{
sum=sum-(float)array[n]; //subtract the nth value of array from current sum of passes
counter=counter-(float)totalnumberoftests[n];
array[n]=consecpass; //set array[n] equal to the number of consecutive passes
totalnumberoftests[n]=consecpass; //set the number of tests for index n = number of passes
sum=sum+(float)array[n]; //add the last number of consecutive passes (stored in array[n]) to the current sum of passes
counter=counter+(float)totalnumberoftests[n];
flag=0; //set the flag==0 so the array indices do not change until event changes
consecfail++;
n++; //set the next index for the arrays
if(n>size)n=0;//if array index is greater than the size of the array, set the index back to zero. This will overwrite the data in array index zero
//RED_LED_ON;
//GREEN_LED_OFF;
}else{
consecpass=0;
consecfail++;
//RED_LED_ON;
//GREEN_LED_OFF;
}
}
if (consecpass>8000) //used to prevent rollover and to indicate failure if device is standing still. 8000 was selected because the absolute minimum speed will be 10cm/s
{
sum=sum-(float)array[n];
counter=counter-(float)totalnumberoftests[n];
array[n]=consecpass;
totalnumberoftests[n]=consecpass;
sum=sum+(float)array[n];
counter=counter+(float)totalnumberoftests[n];
consecpass=0;
n++;
if(n>size)n=0;
}
if(consecfail>30000) //used to prevent rollover and to indicate failure if device is standing still. 30000 was selected because the absolute minimum speed will be 10cm/s
{
sum=sum-(float)array[n];
counter=counter-(float)totalnumberoftests[n];
array[n]=0;
totalnumberoftests[n]=consecfail;
sum=sum+(float)array[n];
counter=counter+(float)totalnumberoftests[n];
consecfail=0;
n++;
if(n>size)n=0;
}
average=(double)sum/(double)counter; //average is a float. The total number of positive tests/total number of tests
if(average<.35 && average > .25 //acceptable passing range
{
GREEN_LED_ON;
RED_LED_OFF;
} else {
GREEN_LED_OFF;
RED_LED_ON;
}
}
}
当平均值应始终介于 0 和 1 之间时，从圆形数组计算的 运行 平均值产生常量 < 0 平均值。
我正在为使用 LED 和光电二极管检测特定类型墨水的 MSP430 设备编写固件。该设备以大约 155us 的速度扫描，扫描仪下的样本速度范围为 0.1m/s 至 3.3m/s。该设备的目标是测试墨水并测量墨水（通过）与测试（未通过）的比率，并在比率介于相应值之间时打开绿色 LED，否则打开红色 LED。我正在使用静态整数数组将连续传递的值和测试值存储到每个数组的相同索引号。在数组的最后一个索引之后，索引被设置回零并覆盖旧值。
GREEN_LED_ON；和类似的定义是我的 MCU 的端口定义并且被验证是正确的。
事件是测试结果。如果检测到墨水，则 event=DETECTED，反之亦然
test 将是 GUI 设置的平均值，但现在它没什么，因为我的函数的这一部分没有工作
通常我会通过随附的 GUI 设置可变平均值，但出于测试目的，我设置平均值 <0 只是为了弄清楚为什么 LED 在错误的时间点亮，我发现我得到的是平均值<0。平均值应始终为 0=
备注：
- 我尝试使用 LED 输出检查代码的各个部分是否正常工作。我注释掉了控制 LED 的平均部分，并通过打开和关闭 LED 验证了 event== 部分是否正常工作。然后我尝试将该代码放入 flag== 部分，并且 LED 也按预期与该部分相对应。
- 我发现数组值有问题。一旦
n > size它只测试一次而不是等待下一个标志更改。我不能 n>size 因为在我的代码中，n++将等于 7，这是越界的
我添加了一段代码以确保不会发生翻转。选择值 8,000 和 30,000 以匹配可能的最慢 运行 速度。
我还更改了数组索引递增的位置，并确保它在数组范围内。
这是更新后的函数：
void display(char event, char test) {
static int size=5;
static int array[6]={0}; //array with number of passes for each n
static int n=0;
static float sum=0;//total number of passes
static float average=0;//average pass rate over n
static int consecpass=0; //consecutive passes
static int consecfail=0; //consecutive fails
static int totalnumberoftests[6]={0}; //total number of tests conducted. Counts the number of passing or failing tests for the nth value
static float counter=1; //used to count the total number of tests
static int flag=0;
if (event == DETECTED)
{
if (flag==0)
{
sum=sum-array[n];
counter=counter-totalnumberoftests[n];
array[n]=0;
totalnumberoftests[n]=consecfail;
sum=sum+array[n];
counter=counter+totalnumberoftests[n];
flag=1;
consecpass++;
n++;
if(n>=size)n=0;
//GREEN_LED_ON;
//RED_LED_OFF;
}else{
consecfail=0;
consecpass++;
//GREEN_LED_ON;
//RED_LED_OFF;
}
} if (event==NOT_DETECTED){
if(flag==1)
{
sum=sum-array[n];
counter=counter-totalnumberoftests[n];
array[n]=consecpass;
totalnumberoftests[n]=consecpass;
sum=sum+array[n];
counter=counter+totalnumberoftests[n];
flag=0;
consecfail++;
n++;
if(n>=size)n=0;
//RED_LED_ON;
//GREEN_LED_OFF;
}else{
consecpass=0;
consecfail++;
//RED_LED_ON;
//GREEN_LED_OFF;
}
}
if (consecpass>8000)
{
sum=sum-array[n];
counter=counter-totalnumberoftests[n];
array[n]=consecpass;
totalnumberoftests[n]=consecpass;
sum=sum+array[n];
counter=counter+totalnumberoftests[n];
consecpass=0;
n++;
if(n>=size)n=0;
}
if(consecfail>30000)
{
sum=sum-array[n];
counter=counter-totalnumberoftests[n];
array[n]=0;
totalnumberoftests[n]=consecfail;
sum=sum+array[n];
counter=counter+totalnumberoftests[n];
consecfail=0;
n++;
if(n>=size)n=0;
}
average=sum/counter;
if(average<.6 && average > .1)
{
GREEN_LED_ON;
RED_LED_OFF;
}else{
GREEN_LED_OFF;
RED_LED_ON;
}
}
if (n >= size) 在标志语句之后声明，以避免我的数组的最终值为 1。这是更改（它在两个 if(flag==) 语句上：
if (flag == 1) {
sum = sum - array[n];
counter = counter - totalnumberoftests[n];
array[n] = consecpass;
totalnumberoftests[n] = consecpass;
sum = sum + array[n];
counter = counter + totalnumberoftests[n];
flag = 0;
consecfail++;
n++;
if (n >= size)
n = 0;
原代码如下：
void display(char event, char test) {
static int size = 6;
static int array[6] = { 0 }; //array with number of passes for each n
static int n = 0;
static float sum = 0;//total number of passes
static float average = 0;//average pass rate over n
static int consecpass = 0; //consecutive passes
static int consecfail = 0; //consecutive fails
static int totalnumberoftests[6] = { 0 }; //total number of tests conducted. Counts the number of passing or failing tests for the nth value
static float counter = 1; //used to count the total number of tests
static int flag = 0;
if (n >= size) {
n = 0;
}
if (event == DETECTED) {
if (flag == 0) {
n++;
sum = sum - array[n];
counter = counter - totalnumberoftests[n];
array[n] = 0;
totalnumberoftests[n] = consecfail;
sum = sum + array[n];
counter = counter + totalnumberoftests[n];
flag = 1;
consecpass++;
} else {
consecfail = 0;
consecpass++;
}
}
if (event == NOT_DETECTED) {
if (flag == 1) {
n++;
sum = sum - array[n];
counter = counter - totalnumberoftests[n];
array[n] = consecpass;
totalnumberoftests[n] = consecpass;
sum = sum + array[n];
counter = counter + totalnumberoftests[n];
flag = 0;
consecfail++;
} else {
consecpass = 0;
consecfail++;
}
}
average = sum / counter;
if (average < 0) {
GREEN_LED_ON;
RED_LED_OFF;
} else {
GREEN_LED_OFF;
RED_LED_ON;
}
}
你有UB。
在顶部你做 if (n>=size) n = 0;。这仍然允许 n 为 size-1
但是，在 访问数组之前，您需要n++ 。这将允许您访问 array[size]，即 UB。
我相信您想将 n++ 移动到 if 部分的底部，在 进行计算之后。而且，您可能希望将两者与 if (++n >= size) n = 0;
更新：
I set size=5 and I still get negative numbers. The arrays are both within the boundary now correct?
可能吧。但是，有几件事。
只有 average 需要 [或应该] float。
您有 "parallel" 个数组。我会改用结构。
我已经重复了你的逻辑几次，但我仍然不确定你想要达到什么目的。
因此，我进行了重构以尝试消除任何更多可能的微不足道的错误。
我对计数器的 subtract-and-then-add-back 有点怀疑，尤其是在切换点。这是您可以得到负数的唯一地方。
也许将该函数插入到模拟各种长度的 ink/no 墨水流数据的单元测试程序中会有所帮助。然后你可以断点。这可以 test/verify 你的逻辑，而不必使用实时系统的痛苦（即单元测试程序是一个普通的应用程序，你可以 运行 在你的电脑上）。您可以有条件地编译 in/out LED 代码与 "abort on negative value"，如下所述。
无论如何，这是我的简化，可能有助于澄清[请原谅不必要的样式清理]：
// NOTE: in the long term, an int could wrap to a negative -- adjust this
// as needed
typedef long long ctr;
struct event {
ctr testcount;
ctr passcount;
};
// NOTE: moved this outside function to guarantee all values are zero at start
#define EVENTMAX 6
struct event events[EVENTMAX];
void
display(char event, char test)
{
static int n = 0;
static ctr sum = 0; // total number of passes
static double average; // average pass rate over n
static ctr consecpass = 0; // consecutive passes
static ctr consecfail = 0; // consecutive fails
static ctr testcount = 1; // used to count the total number of tests
static int flag = 0;
struct event *cur;
cur = &events[n];
if (event == DETECTED) {
if (flag == 0) {
sum -= cur->passcount;
testcount -= cur->testcount;
cur->passcount = 0;
cur->testcount = consecfail;
sum += cur->passcount;
testcount += cur->testcount;
flag = 1;
if (++n >= EVENTMAX)
n = 0;
}
else {
consecfail = 0;
}
consecpass++;
}
if (event == NOT_DETECTED) {
if (flag == 1) {
sum -= cur->passcount;
testcount -= cur->testcount;
cur->passcount = consecpass;
cur->testcount = consecpass;
sum += cur->passcount;
testcount += cur->testcount;
flag = 0;
if (++n >= EVENTMAX)
n = 0;
}
else {
consecpass = 0;
}
consecfail++;
}
// add code to abort program if _either_ sum _or_ testcount is negative
// here ...
average = sum;
average /= testcount;
if (average < 0) {
GREEN_LED_ON;
RED_LED_OFF;
}
else {
GREEN_LED_OFF;
RED_LED_ON;
}
}
更新#2：
I found that one of the problems was roll over. I fixed this with an if statement that stores values if they get higher than 8,000 or 30,000. When I'm in debug mode, the values of the arrays look as I expect them to, but I occasionally get negative numbers in sum and counter. How could the wrong indexes be getting subtracted?
即使索引有效，您也可以从 "stale" 条目中减去。我知道您正在尝试实现 RLE。
一个猜测...
您更改了 "current" 条目，但在 ++n 之后，"other" 方可能会在需要前一个条目时获得 "next" 条目。
也就是说，减去 array[0]，应用东西，设置 array[0]，然后递增 n。
对方现在正在减array[1]，需要减array[0]的时候设置array[1].
因此，从逻辑上讲，您可能会遇到 "off by one" 错误。
不知道。
使用单元测试应用程序，您可以为所有内容添加调试 printf。当负值发生时，停止。然后分析日志。单元测试 could/should 测试所有边缘情况。
如果您将（例如）1x10、0x3、1x5、0x20 的序列输入函数，这些应该显示在 arrays/struct 中。存储的条目应与输入序列匹配。
因此，转储数组以验证计数是否符合预期。
什么值达到 8000/30000？
万一有人回到这里，这是我正在使用的代码，我的 运行 平均值运行良好
void display(char event, char test) {
static int size=9; //size of the array
static int array[10]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //array with number of passes for each n
static int n=0; //number for the index in both arrays
static long int sum=0;//total of passes
static double average=0;//rate of passes per tests. The sum of the values in array[n] divided by total tests in totalnumberoftest[n] attay
static int consecpass=0; //consecutive passes
static int consecfail=0; //consecutive fails
static int totalnumberoftests[10]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //total number of tests conducted. Counts the number of passing or failing tests for the nth value
static long int counter=1; //used to count the total number of tests
static int flag=0;//flag used to indicate when the input goes from event==DETECTED to event==NOT_DETECTED
static int lowlimitb=0;// integer value from low limit b in desert for average setting. Value entered should be the positive tests/total tests percentage
sum=sum-(float)array[n]; //subtract the nth value of array from sum
counter=(float)counter-totalnumberoftests[n];
array[n]=0;//set the nth value to zero, because the previous state of event was NOT_DETECTED, meaning there were no positive tests
totalnumberoftests[n]=consecfail; //add the number of negative tests to total tests
sum=sum+(float)array[n]; //add array index n to sum (should be zero)
counter=counter+(float)totalnumberoftests[n]; //counter is the total number of tests. Add totalnumberoftests with the last index n adds the last consecfail to counter
flag=1; //set flag==1 to indicate the last event was DETECTED
consecpass++; //count a pass
consecfail=0;
n++; //set the next index for the arrays
if(n>size)n=0; //if array index is greater than the size of the array, set the index back to zero. This will overwrite the data in array index zero
//GREEN_LED_ON;
//RED_LED_OFF;
}else{ //the last event=DETECT, no need to change array indices
consecpass++;
//GREEN_LED_ON;
//RED_LED_OFF;
}
} if (event==NOT_DETECTED){
if(flag==1) //flag gets set to 1 in event==DETECTED
{
sum=sum-(float)array[n]; //subtract the nth value of array from current sum of passes
counter=counter-(float)totalnumberoftests[n];
array[n]=consecpass; //set array[n] equal to the number of consecutive passes
totalnumberoftests[n]=consecpass; //set the number of tests for index n = number of passes
sum=sum+(float)array[n]; //add the last number of consecutive passes (stored in array[n]) to the current sum of passes
counter=counter+(float)totalnumberoftests[n];
flag=0; //set the flag==0 so the array indices do not change until event changes
consecfail++;
n++; //set the next index for the arrays
if(n>size)n=0;//if array index is greater than the size of the array, set the index back to zero. This will overwrite the data in array index zero
//RED_LED_ON;
//GREEN_LED_OFF;
}else{
consecpass=0;
consecfail++;
//RED_LED_ON;
//GREEN_LED_OFF;
}
}
if (consecpass>8000) //used to prevent rollover and to indicate failure if device is standing still. 8000 was selected because the absolute minimum speed will be 10cm/s
{
sum=sum-(float)array[n];
counter=counter-(float)totalnumberoftests[n];
array[n]=consecpass;
totalnumberoftests[n]=consecpass;
sum=sum+(float)array[n];
counter=counter+(float)totalnumberoftests[n];
consecpass=0;
n++;
if(n>size)n=0;
}
if(consecfail>30000) //used to prevent rollover and to indicate failure if device is standing still. 30000 was selected because the absolute minimum speed will be 10cm/s
{
sum=sum-(float)array[n];
counter=counter-(float)totalnumberoftests[n];
array[n]=0;
totalnumberoftests[n]=consecfail;
sum=sum+(float)array[n];
counter=counter+(float)totalnumberoftests[n];
consecfail=0;
n++;
if(n>size)n=0;
}
average=(double)sum/(double)counter; //average is a float. The total number of positive tests/total number of tests
if(average<.35 && average > .25 //acceptable passing range
{
GREEN_LED_ON;
RED_LED_OFF;
} else {
GREEN_LED_OFF;
RED_LED_ON;
}
}
}