//#include <LiquidCrystal.h>
// Display senza libreria
// Definizioni dei pin

#define DHT_PIN_EXTERNAL 2   // Collega il sensore DHT esterno al pin 2 di Arduino
#define DHT_PIN_INTERNAL 3   // Collega il sensore DHT interno al pin 3 di Arduino
#define LEDred 6
#define LEDblue 8
volatile int data[5]; // Dati letti dal sensore

float temperature_internal = 20;
float temperature = 0.0;

void setup() {
  cli();
  pinMode(LEDred, OUTPUT);
  pinMode(LEDblue, OUTPUT);

  //Provide power to both LEDs
  //digitalWrite(LEDred, HIGH);
  //digitalWrite(LEDblue, HIGH);


  // Abilita l'interrupt esterno su pin 2
  //EIMSK |= (1 << INT0);
   
   // Abilita l'interrupt esterno su pin 3 (INT1)
  EIMSK |= (1 << INT1);
  /* // Imposta il trigger sull'orlo di salita
  EICRA |= (1 << ISC01) | (1 << ISC00);
  */
  // Change
  //EICRA |= (1 << ISC00);
  // Imposta il trigger sull'orlo di discesa
  EICRA |= (1 << ISC11);

     // Abilita l'interrupt per il gruppo PCINT1 (pin 8-13)
  //PCICR |= (1 << PCIE1);

   // Abilita il maschera interrupt per il gruppo PCINT1 (pin A0-A5)
  //PCMSK1 |= (1 << PC0) | (1 << PC1) | (1 << PC2) | (1 << PC3) | (1 << PC4);
  //PCICR |= B00000010; // We activate the interrupts of the PC port

 /* PCMSK1 |= bit (PCINT13) | bit (PCINT12) | bit (PCINT11);  // want pin A5 or A4 or A3
PCIFR  |= bit (PCIF1);    // clear any outstanding interrupts
  PCICR  |= bit (PCIE1);    // enable pin change interrupts for A0 to A6 and reset */
  /* // Imposta il trigger sull'orlo di discesa
  EICRA |= (1 << ISC01); */
  

  
  // Abilita gli interrupt globali
  //sei();

  /* pinMode(buttonPin2, INPUT);
  pinMode(buttonPin3, INPUT);
  pinMode(buttonPin4, INPUT); */

  

  //lcd.begin(16, 2); // Inizializza il display LCD con 16 colonne e 2 righe
  //lcd.print("Hello, Arduino!"); // Stampa il testo sul display LCD



  // Configura l'ADC
  ADMUX = 0; // Usa il riferimento AREF, bit di sinistra a 0
  ADMUX |= (1 << REFS0); // Riferimento esterno a 5V
  ADCSRA |= (1 << ADEN); // Abilita l'ADC


  // Configura il timer per generare l'interrupt a intervalli di 50 us
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;
  
  // Imposta il confronto a 10 (50 us su un clock a 16 MHz)
  //OCR1A = 10;
  OCR1A = 15624; // 1 secondo
  //OCR1A = 20000;
   
  
  // Abilita il timer con prescaler 1
  //TCCR1B |= (1 << CS10); 
  // 1024
  TCCR1B |= (1 << CS12) | (1 << CS10);
  //TCCR1B = (TCCR1B & 0xF8) | 0x05;
  // Abilita l'interrupt per il confronto A
  TIMSK1 |= (1 << OCIE1A);
  /* TCCR1B |= (1 << WGM12); // Abilito la modalità di confronto CTC
  //TCCR1B = (TCCR1B & 0xF8) | 0x01; // Simulazione giornata con prescaler a 1
  TCCR1B = (TCCR1B & 0xF8) | 0x05; // Imposto il prescaler a 1024
  //TCCR1B = (TCCR1B & 0xF8) | 0x01; // Simulazione giornata con prescaler a 1
  TIMSK1 |= (1 << OCIE1A); // Abilito l'interrupt di confronto A del timer 1 */
  



    Serial.begin(9600);
sei();
}


void loop() {

   //cli();
  //ROBA POTENZIOMETRO
  /* int potenziometroValue = readPotentiometer(potenziometroPin);
  //int asd = analogReadd(A0);
  Serial.print("Valore del potenziometro : ");
  Serial.println(potenziometroValue);
  int CO2Value = potenziometroValue * 4;
  Serial.print("Livello CO2 : ");
  Serial.println(CO2Value); */
  //delay(200); // Aggiungi un piccolo ritardo tra le letture per evitare letture multiple istantanee
  

  //ROBA DHT22
  // Leggi i dati dal sensore DHT esterno (temperatura & umidità)
  /* float temperature_external = dht_external.readTemperature();
  float humidity_external = dht_external.readHumidity();

  // Leggi i dati dal sensore DHT interno (temperatura & umidità)
  float temperature_internal = dht_internal.readTemperature();
  float humidity_internal = dht_internal.readHumidity(); */

  
  // Visualizza i dati sul terminale seriale
  /* Serial.println("Dati sensore DHT esterno:");
  Serial.print("Temperatura: ");
  Serial.print(temperature_external);
  Serial.println(" °C\t"); */
  /* Serial.print("Umidità: ");
  Serial.print(humidity_external);
  Serial.println(" %"); */

  /* Serial.println("Dati sensore DHT interno:");
  Serial.print("Temperatura: ");
  Serial.print(temperature_internal);
  Serial.println(" °C\t"); */
  /* Serial.print("Umidità: ");
  Serial.print(humidity_internal);
  Serial.println(" %"); */
  //temperature = customReadDHT22();
  //float temperature = calculateTemperature();
  digitalWrite(LEDred, HIGH);
  //delay(1000);
  digitalWrite(LEDred,LOW);
  // Stampa la temperatura
  Serial.print("Temperatura CUSTOM : ");
  Serial.print(temperature);
  Serial.println(" °C");
  //delay(2000); // Intervallo di lettura tra un campione e l'altro
//sei();

}

int readPotentiometer(int pin) {
  ADMUX = 0x40 | (pin & 0x07); // Imposta il pin da leggere
  ADCSRA |= (1 << ADSC); // Avvia la conversione
  // Attendi la fine della conversione
  while (ADCSRA & (1 << ADSC)) {
    // Attendi
  }
  return ADC; // Restituisci il valore letto
}

/*
// L'ISR per l'interrupt esterno su pin 2
ISR(INT0_vect) {
  // Leggi lo stato del pulsante
  buttonState1 = customDigitalRead(buttonPin1);
  
  Serial.println("Interrupt attivato!");
  Serial.println(buttonState1);
  Serial.println("dentro interrupt");
  delay(100);
}
*/
// Funzione personalizzata per impostare la modalità del pin
void customPinMode(int pin, int mode) {
  if (mode == INPUT) {
    if (pin < 8) {
      DDRD &= ~(1 << pin);
    } else if (pin < 14) {
      DDRB &= ~(1 << (pin - 8));
    }
  } else if (mode == OUTPUT) {
    if (pin < 8) {
      DDRD |= (1 << pin);
    } else if (pin < 14) {
      DDRB |= (1 << (pin - 8));
    }
  }
}

int customDigitalRead(int pin) {
  if (pin < 8) {
    return (PIND & (1 << pin)) ? HIGH : LOW;
  } else if (pin < 14) {
    return (PINB & (1 << (pin - 8))) ? HIGH : LOW;
  }
  return LOW;
}

void customDigitalWrite(int pin, int value) {
  if (value == LOW) {
    if (pin < 8) {
      PORTD &= ~(1 << pin);
    } else if (pin < 14) {
      PORTB &= ~(1 << (pin - 8));
    }
  } else if (value == HIGH) {
    if (pin < 8) {
      PORTD |= (1 << pin);
    } else if (pin < 14) {
      PORTB |= (1 << (pin - 8));
    }
  }
}


/* // ISR per il gruppo PCINT1 (pin A0-A5)
ISR(PCINT1_vect) {
  // Leggi lo stato dei bottoni
  buttonState1 = (PINC & (1 << PC1)) ? HIGH : LOW;
  buttonState2 = (PINC & (1 << PC2)) ? HIGH : LOW;
  buttonState3 = (PINC & (1 << PC3)) ? HIGH : LOW;
  buttonState4 = (PINC & (1 << PC4)) ? HIGH : LOW;
} */

float customReadDHT22() {
  // Inizia la comunicazione con il sensore DHT22

  customPinMode(DHT_PIN_INTERNAL, OUTPUT);
  customDigitalWrite(DHT_PIN_INTERNAL, LOW);
  //delay(20);
  delayMicroseconds(1000);
  customDigitalWrite(DHT_PIN_INTERNAL, HIGH);
  delayMicroseconds(40);
  customPinMode(DHT_PIN_INTERNAL, INPUT);

  // Attendi la risposta del sensore
  while (customDigitalRead(DHT_PIN_INTERNAL) == HIGH);

  // Attendi che il sensore inizi la trasmissione dei dati
  while (customDigitalRead(DHT_PIN_INTERNAL) == LOW);

  // Attendi che il sensore finisca di trasmettere i dati
  while (customDigitalRead(DHT_PIN_INTERNAL) == HIGH);

  // Leggi i dati dal sensore
  //int sensorData[5];
  cli();
  for (int i = 0; i < 5; i++) {
    int value = 0;
    for (int j = 0; j < 8; j++) {
      while (customDigitalRead(DHT_PIN_INTERNAL) == LOW);
      delayMicroseconds(50);
      if (customDigitalRead(DHT_PIN_INTERNAL) == HIGH) {
        value |= (1 << (7 - j));
      }
      while (customDigitalRead(DHT_PIN_INTERNAL) == HIGH);
    }
    data[i] = value;
  }
  
  // Calcola la temperatura
  temperature = ((data[2] & 0x7F) << 8 | data[3]) * 0.1;
  if (data[2] & 0x80) {
    temperature = -temperature;
  }
  sei();
  //Serial.println(temperature);
  //Serial.println("AASDD");
  //return temperature;
}

/* int readByte() {
  int value = 0;
  for (int i = 0; i < 8; i++) {
    while (customDigitalRead(DHT_PIN_INTERNAL) == LOW);
    delayMicroseconds(30);
    if (customDigitalRead(DHT_PIN_INTERNAL) == HIGH) {
      value |= (1 << (7 - i));
    }
    while (customDigitalRead(DHT_PIN_INTERNAL) == HIGH);
  }
  return value;
} */

// Funzione ISR per gestire l'interrupt
ISR(TIMER1_COMPA_vect) {
  /* unsigned long currentTime = micros();
  static unsigned long lastTransitionTime = 0;
  
  // Verifica se è trascorso abbastanza tempo dall'ultima transizione
  if (currentTime - lastTransitionTime >= 50) {
    lastTransitionTime = currentTime;
    
    // Imposta il flag dei dati pronti
    //dataReady = true;
    digitalWrite(LEDblue, HIGH);
    digitalWrite(LEDblue,LOW);
    Serial.println("interrupt");
    customReadDHT22();
  } */
  digitalWrite(LEDblue, HIGH);
  Serial.println("interrupt");
  customReadDHT22();
  digitalWrite(LEDblue,LOW);
}