#include <Arduino.h>
#include <math.h>

// ------------------- CONFIGURAÇÕES -------------------
// Pinos PWM (saída)
const int PIN_PWM_A = D3;
const int PIN_PWM_B = D5;
const int PIN_PWM_C = D6;

// Pinos ADC (entrada de potenciômetro)
const int PIN_ADC_A = A0;
const int PIN_ADC_B = A1;
const int PIN_ADC_C = A2;

// Pinos DEBUG (seno puro -> quadrado)
const int DBG_A = D7;
const int DBG_B = D8;
const int DBG_C = D9;

// Parâmetros do sinal
const float FREQ_HZ = 60.0f;       // Frequência da senoide
const float PERIODO = 1.0f / FREQ_HZ;
const float PHASE = PERIODO / 3.0f; // 120° = 5,55 ms

// Parâmetros do PWM (software)
const int PWM_RES = 200;           // resolução
const unsigned long PWM_TICK_US = 10;   // passo do PWM
const unsigned long UPDATE_US = 100;    // atualização das senoides (10 kHz)

// ------------------- VARIÁVEIS -------------------
int dutyA = 0, dutyB = 0, dutyC = 0;
int pwm_counter = 0;

unsigned long last_update = 0;
unsigned long last_pwm = 0;

// ------------------- SETUP -------------------
void setup() {
  // PWM
  pinMode(PIN_PWM_A, OUTPUT);
  pinMode(PIN_PWM_B, OUTPUT);
  pinMode(PIN_PWM_C, OUTPUT);

  // Debug
  pinMode(DBG_A, OUTPUT);
  pinMode(DBG_B, OUTPUT);
  pinMode(DBG_C, OUTPUT);
}

// ------------------- LOOP -------------------
void loop() {
  unsigned long t_us = micros();

  // Atualização da senoide
  if (t_us - last_update >= UPDATE_US) {
    last_update = t_us;

    float t = t_us / 1e6f; // tempo em segundos

    // Senoides com defasagem fixa (±120°)
    float sA = sinf(2.0f * M_PI * FREQ_HZ * t);
    float sB = sinf(2.0f * M_PI * FREQ_HZ * (t - PHASE));
    float sC = sinf(2.0f * M_PI * FREQ_HZ * (t + PHASE));

    // Debug -> converte seno em quadrado (0/1) para medir defasagem
    digitalWrite(DBG_A, (sA > 0) ? HIGH : LOW);
    digitalWrite(DBG_B, (sB > 0) ? HIGH : LOW);
    digitalWrite(DBG_C, (sC > 0) ? HIGH : LOW);

    // Amplitude vinda dos potenciômetros (0..1)
    float ampA = analogRead(PIN_ADC_A) / 4095.0f;
    float ampB = analogRead(PIN_ADC_B) / 4095.0f;
    float ampC = analogRead(PIN_ADC_C) / 4095.0f;

    // Aplica amplitude apenas no DUTY (não na fase!)
    float dA = 0.5f + 0.5f * (sA * ampA);
    float dB = 0.5f + 0.5f * (sB * ampB);
    float dC = 0.5f + 0.5f * (sC * ampC);

    dutyA = (int)(constrain(dA, 0.0f, 1.0f) * PWM_RES);
    dutyB = (int)(constrain(dB, 0.0f, 1.0f) * PWM_RES);
    dutyC = (int)(constrain(dC, 0.0f, 1.0f) * PWM_RES);
  }

  // PWM por software
  if (t_us - last_pwm >= PWM_TICK_US) {
    last_pwm = t_us;

    digitalWrite(PIN_PWM_A, (pwm_counter < dutyA) ? HIGH : LOW);
    digitalWrite(PIN_PWM_B, (pwm_counter < dutyB) ? HIGH : LOW);
    digitalWrite(PIN_PWM_C, (pwm_counter < dutyC) ? HIGH : LOW);

    pwm_counter++;
    if (pwm_counter >= PWM_RES) pwm_counter = 0;
  }
}