switched to camelCase

Author: JamesTimothyMeech

benchmarks/source/superh/pedometerExample/virtualSensorExample.c

@@ -20,14 +20,14 @@
 #include "misc.h"
 #include "print.h"
 
-enum samples {BUFFER_SIZE = 400};
+enum samples {numberOfSamples = 400};
 struct 
-accel_axis
+accelAxis
 {
  /*
  *	Hold data and info about single acceleration axis:
  */ 
-float data[BUFFER_SIZE]; /*
+float data[numberOfSamples]; /*
  *	array to store filtered data
  */
 floatmax; /*
@@ -37,7 +37,7 @@ accel_axis
  float min; /*
  *	minimum data entry
  */ 
- float p2p; /*
+ float peakToPeak; /*
  *	peak to peak value
  */
  float thresh; /*
@@ -46,17 +46,17 @@ accel_axis
 };
 
 void 
-findAxisProperties(struct accel_axis *axis)
+findAxisProperties(struct accelAxis *axis)
 {
  /*
  * Find peak-to-peak value and threshold for single-axis data
  */
  float max = axis->data[0];
  floatmin = axis->data[0];
- floatp2p;
+ floatpeakToPeak;
  floatthresh;
 
- for (int i=0; i<BUFFER_SIZE; i++)
+ for (int i=0; i<numberOfSamples; i++)
 {
  if (axis->data[i] > max)
 {
@@ -68,55 +68,55 @@ findAxisProperties(struct accel_axis *axis)
 	}
  }
 
- p2p = max-min;
+ peakToPeak = max-min;
  thresh = (max+min)/2.0;
 
  /*
  *	Write values into struct
  */
  axis->max = max;
  axis->min = min;
- axis->p2p = p2p;
+ axis->peakToPeak = peakToPeak;
  axis->thresh = thresh;
 }
 
 int 
-chooseAxis(struct accel_axis *x, struct accel_axis *y, struct accel_axis *z, float calib)
+chooseAxis(struct accelAxis *x, struct accelAxis *y, struct accelAxis *z, float calib)
 {
  /*
  *	Perform maximum activity axis selection
  */
 
- floatp2p[3];
- floatmax_p2p = 0;
- intmax_index;
+ floatpeakToPeak[3];
+ floatmaxPeakToPeak = 0;
+ intmaxIndex;
 
  findAxisProperties(x);
  findAxisProperties(y);
  findAxisProperties(z);
 
- p2p[0] = x->p2p;
- p2p[1] = y->p2p;
- p2p[2] = z->p2p;
+ peakToPeak[0] = x->peakToPeak;
+ peakToPeak[1] = y->peakToPeak;
+ peakToPeak[2] = z->peakToPeak;
 
  /*
  *	Find axis with greatest peak-to-peak (p2p) amplitude
  */
  for (int i = 0; i < 3; i++)
 {
- if (p2p[i] > max_p2p)
+ if (peakToPeak[i] > maxPeakToPeak)
 {
- max_p2p = p2p[i];
- max_index = i;
+ maxPeakToPeak = peakToPeak[i];
+ maxIndex = i;
 	}
  }
 
  /*
  *	If p2p value of chosen axis is above amplitude calibration value then return chosen axis
  */
- if (max_p2p > calib) 
+ if (maxPeakToPeak > calib) 
 {
-return (max_index + 1);
+return (maxIndex + 1);
  }
 
  /*
@@ -130,15 +130,15 @@ chooseAxis(struct accel_axis *x, struct accel_axis *y, struct accel_axis *z, flo
 }
 
 float 
-detectSteps(struct accel_axis *chosen)
+detectSteps(struct accelAxis *chosen)
 {
 /*
  *	Finds where threshold is crossed in negative slope direction
  */
 
  floatsteps = 0;
  floatcurrent, next;
- for(int i=0; i<BUFFER_SIZE-1;i++)
+ for(int i=0; i<numberOfSamples-1;i++)
 {
  current = chosen->data[i];
  next = chosen->data[i+1];
@@ -151,9 +151,9 @@ detectSteps(struct accel_axis *chosen)
 }
 
 void 
-readRawData(float *t_buffer, float *x_buffer, float *y_buffer, float *z_buffer)
+readRawData(float *tBuffer, float *xBuffer, float *yBuffer, float *zBuffer)
 {
-for(int j = 0; j < BUFFER_SIZE; j++)
+for(int j = 0; j < numberOfSamples; j++)
 	{
 /* 
  * Insert delay of 2500 uSeconds to simulate 400 Hz sample rate
@@ -162,16 +162,17 @@ readRawData(float *t_buffer, float *x_buffer, float *y_buffer, float *z_buffer)
 /* 
  * Read sensor readings from sigsrc 0 which is the x-axis accelerometer readings
  */
- x_buffer[j] = devsignal_read(0);
+ xBuffer[j] = devsignal_read(0);
 /* 
  * Read sensor readings from sigsrc 1 which is the y-axis accelerometer readings
  */
- y_buffer[j] = devsignal_read(1);
+ yBuffer[j] = devsignal_read(1);
 /* 
  * Read sensor readings from sigsrc 2 which is the z-axis accelerometer readings
  */ 
- z_buffer[j] = devsignal_read(2);
-/*	Please note that sigsrc simulates a real signal which changes in time. 
+ zBuffer[j] = devsignal_read(2);
+/*
+ *	Please note that sigsrc simulates a real signal which changes in time. 
  *	The value returned by devsignal_read() will be different at different simulation times.
  *	Here we use delay to wait for 1/f seconds where f is the 400 Hz sample frequency specified in the run.m file. 
  *	If we don't wait for this amount of time and instead sample as quickly as we can we will see the same sensor value many times. 
@@ -182,7 +183,7 @@ readRawData(float *t_buffer, float *x_buffer, float *y_buffer, float *z_buffer)
 }
 
 void 
-MovingAvgFilter(float input[], struct accel_axis *output)
+MovingAvgFilter(float input[], struct accelAxis *output)
 {
 /*
  *	Implement moving average low pass filtering
@@ -194,13 +195,13 @@ MovingAvgFilter(float input[], struct accel_axis *output)
  /*
  *	calculate mean of input array
  */
- for (int i=0; i<BUFFER_SIZE; i++) 
+ for (int i=0; i<numberOfSamples; i++) 
 {
  sum += input[i];
  }
- mean = sum/BUFFER_SIZE;
+ mean = sum/numberOfSamples;
 
- for (int i=0; i<BUFFER_SIZE; i++) 
+ for (int i=0; i<numberOfSamples; i++) 
 {
  /*
  *	Find mean-subtracted input
@@ -212,7 +213,7 @@ MovingAvgFilter(float input[], struct accel_axis *output)
  output->data[i] = 0;
  }
 
- for (int i=0; i<BUFFER_SIZE; i++) 
+ for (int i=0; i<numberOfSamples; i++) 
 {
  output->data[i] = input[i];
  }
@@ -222,41 +223,35 @@ MovingAvgFilter(float input[], struct accel_axis *output)
 int
 main(void)
 {
-intchosen_axis;
+intchosenAxis;
 floatsteps;
-floatsteps_total = 0;
-floatcalib_max;/*
- *	used in calibration stage
- */
-booluse_butterworth;/*
- *	if true use Butterworth filter, else use Moving Average filter
- */ 
+floattotalSteps = 0;
+
+/*
+ *	used in calibration stage
+ */
+floatcalibrationMax;
 
 /* 
  *	Declare buffers to hold raw unfiltered acceleration data
  */
- floatt_buffer[BUFFER_SIZE];
- floatx_buffer[BUFFER_SIZE];
- floaty_buffer[BUFFER_SIZE];
- floatz_buffer[BUFFER_SIZE];
+ floattBuffer[numberOfSamples];
+ floatxBuffer[numberOfSamples];
+ floatyBuffer[numberOfSamples];
+ floatzBuffer[numberOfSamples];
 
 /*
  *	Declare struct for each acceleration axis (for use after filtering)
  */
- structaccel_axis x_accel;
- structaccel_axis y_accel;
- structaccel_axis z_accel;
-
-/*
- *	Select type of filtering
- */
- use_butterworth = false;
+ structaccelAxis xAcceleration;
+ structaccelAxis yAcceleration;
+ structaccelAxis zAcceleration;
 
 /*
  *	empirically calculated minimum allowable calibration value
  *	in units of 0.25 mg
  */
- calib_max = 1;
+ calibrationMax = 1;
 
 /* 
  *	Stage 2: Step Detection
@@ -265,44 +260,44 @@ main(void)
  /*
  *	Read raw tri-axial accelerometer data and store in buffers
  */
- readRawData(t_buffer, x_buffer, y_buffer, z_buffer);
+ readRawData(tBuffer, xBuffer, yBuffer, zBuffer);
 
-MovingAvgFilter(x_buffer, &x_accel);
- MovingAvgFilter(y_buffer, &y_accel);
- MovingAvgFilter(z_buffer, &z_accel);
+MovingAvgFilter(xBuffer, &xAcceleration);
+ MovingAvgFilter(yBuffer, &yAcceleration);
+ MovingAvgFilter(zBuffer, &zAcceleration);
 
  /*
  *	Peform maximal activity axis selection
  */
- chosen_axis = chooseAxis(&x_accel, &y_accel, &z_accel, calib_max);
- if(chosen_axis == 1)
+ chosenAxis = chooseAxis(&xAcceleration, &yAcceleration, &zAcceleration, calibrationMax);
+ if(chosenAxis == 1)
 {
- steps = detectSteps(&x_accel);
+ steps = detectSteps(&xAcceleration);
  }
 
- else if(chosen_axis == 2)
+ else if(chosenAxis == 2)
 {
- steps = detectSteps(&y_accel);
+ steps = detectSteps(&yAcceleration);
  }
 
- else if(chosen_axis == 3)
+ else if(chosenAxis == 3)
 {
- steps = detectSteps(&z_accel);
+ steps = detectSteps(&zAcceleration);
  }
 
  else 
 {
  steps = 0;
  }
- steps_total += steps;
+ totalSteps += steps;
 
  /*
  *	Reset count to 0 if it reaches 100
  */
- if (steps_total > 99)
+ if (totalSteps > 99)
 {
- steps_total = 0;
+ totalSteps = 0;
  } 
- printf("Total steps = %f\n", steps_total);
+ printf("Total steps = %f\n", totalSteps);
 return 0;
 }