#define SMOOTHING_WINDOW 10 // Number of samples for moving average (input smoothing)

// Define the pins for the oil pressure gauge control
#define oil_sine_plus 6 // Pin 6 - Controls the voltage to the sine coil (PWM)
#define oil_sine_minus 10 // Pin 10 - Controls the polarity of the sine coil
#define oil_cosine_plus 4 // Pin 4 - Controls the voltage to the cosine coil (PWM)
#define oil_cosine_minus 2 // Pin 2 - Controls the polarity of the cosine coil

// Define the pins for the water temperature gauge control
#define water_sine_plus 9 // Pin 9 - Controls the voltage to the sine coil (PWM)
#define water_sine_minus 8 // Pin 8 - Controls the polarity of the sine coil
#define water_cosine_plus 7 // Pin 7 - Controls the voltage to the cosine coil (PWM)
#define water_cosine_minus 5 // Pin 5 - Controls the polarity of the cosine coil

// Define input pins
#define oilPressurePin A1 // Pin A1 - Potentiometer for oil pressure
#define waterTempPin A3 // Pin A3 - Potentiometer for water temperature

// Smoothing variables
int oilPotValues[SMOOTHING_WINDOW];
int waterPotValues[SMOOTHING_WINDOW];
int oilPotIndex = 0;
int waterPotIndex = 0;
long oilSum = 0, waterSum = 0;
int smoothedOilPotValue = 0, smoothedWaterPotValue = 0;

// Variables for needle positions
int lastOilPosition = 0;
int lastWaterPosition = 0;

// Smoothing factors
float smoothingFactor = 0.1; // Output smoothing factor for both gauges

int delayTime = 10; // milliseconds between each angular step

// Sinusoidal lookup table for 0-89 degrees in 8-bit resolution
const PROGMEM uint8_t Sine_Lookup[90] = {
0, 4, 9, 13, 18, 22, 27, 31, 35, 40, 44, 49, 53, 57, 62, 66,
70, 75, 79, 83, 87, 91, 96,100,104,108,112,116,120,124,127,131,
135,139,143,146,150,153,157,160,164,167,171,174,177,180,183,186,
190,192,195,198,201,204,206,209,211,214,216,219,221,223,225,227,
229,231,233,235,236,238,240,241,243,244,245,246,247,248,249,250,
251,252,253,253,254,254,254,255,255,255
};

// Scaling factor to ensure full range of PWM
const float PWM_ScaleFactor = 1;

void setup() {
Serial.begin(115200);

// Pins for oil pressure gauge
pinMode(oil_sine_plus, OUTPUT);
pinMode(oil_cosine_plus, OUTPUT);
pinMode(oil_sine_minus, OUTPUT);
pinMode(oil_cosine_minus, OUTPUT);

// Pins for water temperature gauge
pinMode(water_sine_plus, OUTPUT);
pinMode(water_cosine_plus, OUTPUT);
pinMode(water_sine_minus, OUTPUT);
pinMode(water_cosine_minus, OUTPUT);

// Pins for potentiometer inputs
pinMode(oilPressurePin, INPUT);
pinMode(waterTempPin, INPUT);

// Initialize arrays for smoothing
for (int i = 0; i < SMOOTHING_WINDOW; i++) {
oilPotValues = 0;
waterPotValues = 0;
}

// Modify PWM frequency for smoother output (optional, based on your setup)
TCCR1B = TCCR1B & B11111000 | B00000010; // PWM frequency of 3921.16 Hz for smoother transitions
}

void loop() {
// Read potentiometer values
int oilPotValue = analogRead(oilPressurePin);
int waterPotValue = analogRead(waterTempPin);

// Apply smoothing for oil pressure input
oilSum -= oilPotValues[oilPotIndex];
oilPotValues[oilPotIndex] = oilPotValue;
oilSum += oilPotValue;
oilPotIndex = (oilPotIndex + 1) % SMOOTHING_WINDOW;
smoothedOilPotValue = oilSum / SMOOTHING_WINDOW;

// Apply smoothing for water temperature input
waterSum -= waterPotValues[waterPotIndex];
waterPotValues[waterPotIndex] = waterPotValue;
waterSum += waterPotValue;
waterPotIndex = (waterPotIndex + 1) % SMOOTHING_WINDOW;
smoothedWaterPotValue = waterSum / SMOOTHING_WINDOW;

// Map smoothed potentiometer values to full gauge range (0 to 719)
int oilTargetPosition = map(smoothedOilPotValue, 204.6, 716, 0, 719); // 1-5v 0-200psi
int waterTargetPosition = map(smoothedWaterPotValue, 102, 921, 0, 719); // TMP36 -40 to +257F, .5-4.5v

// Smooth output positions using exponential moving average
lastOilPosition = smoothingFactor * oilTargetPosition + (1 - smoothingFactor) * lastOilPosition;
lastWaterPosition = smoothingFactor * waterTargetPosition + (1 - smoothingFactor) * lastWaterPosition;

// Update both gauges
setOilPressureGauge(lastOilPosition);
setWaterTempGauge(lastWaterPosition);

delay(delayTime); // Small delay to control the update rate
}

void setOilPressureGauge(int pos) {
int sinCoilValue;
int cosCoilValue;

while (pos > 359) pos -= 360; // Keep angle between 0 and 359 degrees

// Logic for controlling the oil pressure gauge (same as previously)
if (pos >= 270) {
digitalWrite(oil_sine_minus, HIGH);
digitalWrite(oil_cosine_minus, LOW);
sinCoilValue = 255 - pgm_read_byte(&(Sine_Lookup[359 - pos]));
cosCoilValue = pgm_read_byte(&(Sine_Lookup[pos - 270]));
}
else if (pos >= 180) {
digitalWrite(oil_sine_minus, HIGH);
digitalWrite(oil_cosine_minus, HIGH);
sinCoilValue = 255 - pgm_read_byte(&(Sine_Lookup[pos - 180]));
cosCoilValue = 255 - pgm_read_byte(&(Sine_Lookup[269 - pos]));
}
else if (pos >= 90) {
digitalWrite(oil_sine_minus, LOW);
digitalWrite(oil_cosine_minus, HIGH);
sinCoilValue = pgm_read_byte(&(Sine_Lookup[179 - pos]));
cosCoilValue = 255 - pgm_read_byte(&(Sine_Lookup[pos - 90]));
}
else {
digitalWrite(oil_sine_minus, LOW);
digitalWrite(oil_cosine_minus, LOW);
sinCoilValue = pgm_read_byte(&(Sine_Lookup[pos]));
cosCoilValue = pgm_read_byte(&(Sine_Lookup[89 - pos]));
}

// Write PWM values to the pins for the oil pressure gauge
analogWrite(oil_sine_plus, sinCoilValue);
analogWrite(oil_cosine_plus, cosCoilValue);
}

void setWaterTempGauge(int pos) {
int sinCoilValue;
int cosCoilValue;

while (pos > 359) pos -= 360; // Keep angle between 0 and 359 degrees

// Logic for controlling the water temperature gauge (same as oil pressure logic)
if (pos >= 270) {
digitalWrite(water_sine_minus, HIGH);
digitalWrite(water_cosine_minus, LOW);
sinCoilValue = 255 - pgm_read_byte(&(Sine_Lookup[359 - pos]));
cosCoilValue = pgm_read_byte(&(Sine_Lookup[pos - 270]));
}
else if (pos >= 180) {
digitalWrite(water_sine_minus, HIGH);
digitalWrite(water_cosine_minus, HIGH);
sinCoilValue = 255 - pgm_read_byte(&(Sine_Lookup[pos - 180]));
cosCoilValue = 255 - pgm_read_byte(&(Sine_Lookup[269 - pos]));
}
else if (pos >= 90) {
digitalWrite(water_sine_minus, LOW);
digitalWrite(water_cosine_minus, HIGH);
sinCoilValue = pgm_read_byte(&(Sine_Lookup[179 - pos]));
cosCoilValue = 255 - pgm_read_byte(&(Sine_Lookup[pos - 90]));
}
else {
digitalWrite(water_sine_minus, LOW);
digitalWrite(water_cosine_minus, LOW);
sinCoilValue = pgm_read_byte(&(Sine_Lookup[pos]));
cosCoilValue = pgm_read_byte(&(Sine_Lookup[89 - pos]));
}

// Write PWM values to the pins for the water temperature gauge
analogWrite(water_sine_plus, sinCoilValue);
analogWrite(water_cosine_plus, cosCoilValue);
}