#include <LiquidCrystal_I2C.h>
#include <Wire.h>

                                                                      /*
                                                                          lcd.setCursor(5, 0);
                                                                          lcd.write((byte)0);
                                                                          lcd.setCursor(6, 0);
                                                                          lcd.write((byte)1);
                                                                          lcd.setCursor(7, 0);
                                                                          lcd.write((byte)2);
                                                                          lcd.setCursor(8, 0);
                                                                          lcd.write((byte)3); 
                                                                          lcd.setCursor(9, 0);
                                                                          lcd.write((byte)4);
                                                                          lcd.setCursor(10, 0);
                                                                          lcd.write((byte)5); 
                                                                          lcd.setCursor(11, 0);
                                                                          lcd.write((byte)6);
                                                                          lcd.setCursor(12, 0);
                                                                          lcd.write((byte)7); 
                                                                     */
                                                                          

                                                                        byte kademe_0[] = {
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B11111
                                                                        };
                                                                        byte kademe_1[] = {
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B11111,
                                                                          B11111
                                                                        };
                                                                        byte kademe_2[] = {
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111
                                                                        };
                                                                        byte kademe_3[] = {
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111
                                                                        };
                                                                        byte kademe_4[] = {
                                                                          B00000,
                                                                          B00000,
                                                                          B00000,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111
                                                                        };
                                                                        byte kademe_5[] = {
                                                                          B00000,
                                                                          B00000,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111
                                                                        };
                                                                        byte kademe_6[] = {
                                                                          B00000,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111
                                                                        };
                                                                        byte kademe_7[] = {
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111,
                                                                          B11111
                                                                        };

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,16,2);

const int maxSicaklik = 150; // Maksimum ses seviyesi
const int minSicaklik = 0; // Minimum ses seviyesi

int i = 0; //sayicisicaklik
int j = 0; //sayiciyakit

//#define tetik A0
//#define kizdirma 4
#define fuel A1
#define sicaklik A2
#define kizdirma 4

int sensSicaklik=0;
int degerSicaklik=0;
int sondegerSicaklik=-1;
int kademeSicaklik=0;
int eksikKademe=0;

int sensYakit=0;
int degerYakit=0;
int sondegerYakit=0;
int kademeYakit=0;
//direnç değerleri 100k ya 100k sicaklik icin

void setup() {

  
  lcd.init();          
  lcd.backlight();     
  lcd.clear();

  lcd.createChar(0, kademe_0);
  lcd.createChar(1, kademe_1);
  lcd.createChar(2, kademe_2);
  lcd.createChar(3, kademe_3);
  lcd.createChar(4, kademe_4);
  lcd.createChar(5, kademe_5);
  lcd.createChar(6, kademe_6);
  lcd.createChar(7, kademe_7);
 
  //pinMode(tetik,INPUT); 
  //pinMode(kizdirma,OUTPUT);
  pinMode(sicaklik, INPUT);
  pinMode(fuel, INPUT);

  pinMode(2,INPUT);
  pinMode(3, INPUT);

  
    lcd.setCursor(0, 0); 
  lcd.print("       HYSTER       ");    
  delay(500);
  lcd.setCursor(1, 1);      
  lcd.print("    OMEGA ISTIF     ");
 delay(800); 
  lcd.clear();


 
  lcd.setCursor(0, 0); 
  lcd.print("FUEL:");
lcd.setCursor(0, 1); 
  lcd.print("TEMP:");
  
}


void loop() {
   if(digitalRead(tetik) == 1)
  digitalWrite(kizdirma,HIGH);
  delay(8000);
  digitalWrite(kizdirma,LOW);
  while(digitalRead(kizdirma)==LOW);

  sensSicaklik=analogRead(sicaklik); //okunan değer bit değerinde 240-965 arasındadır. 2-8 volt müşür çıkışı alındı. 100kya 100k gerilim bölücüden 1-4volt arası input edildi.
  sensSicaklik=1024-sensSicaklik; //bit değeri yükselince sıcaklık artışı sağlansın diye böyle yapıldı
  degerSicaklik=map(sensSicaklik,0,1024,20,200); //bit değeri 0-150 derece arasında gezdiriliyor.
 
  sensYakit=analogRead(fuel); //okunan değer bit değerinde 240-965 arasındadır. 2-8 volt müşür çıkışı alındı. 100kya 100k gerilim bölücüden 1-4volt arası input edildi.
  degerYakit=map(sensYakit,0,1024,0,100); //bit değeri 0-150 derece arasında gezdiriliyor.

  // LCD ekranı güncelleme
  updateLCD();
}


void updateLCD() {
  // Sadece değer değiştiğinde LCD'yi güncelleme

  if (degerSicaklik != sondegerSicaklik) {

    kademeSicaklik=map(degerSicaklik,20,200,0,7);
    kademeSicaklik=kademeSicaklik+1;
    barDoldurma(kademeSicaklik);

    if(degerSicaklik<=100){
      lcd.setCursor(7,1);
      lcd.print(" ");
    }
    lcd.setCursor(5, 1);
    lcd.print(degerSicaklik);

    sondegerSicaklik = degerSicaklik; 
  }

  if (degerYakit != sondegerYakit) {

    kademeYakit=map(degerYakit,0,100,0,7);
    kademeYakit=kademeYakit+1;
    barDoldurma2(kademeYakit);

    if(degerYakit<=100){
      lcd.setCursor(7,0);
      lcd.print(" ");
    }
    lcd.setCursor(5, 0);
    lcd.print(degerYakit);

    sondegerYakit = degerYakit; 
  }
}


void barDoldurma(int kademe1) {
  const int kacBolme = 8; // 
  int suankiCubuk1 = kademe1 * kacBolme / 5;
  for (int i = 0; i < kacBolme; i++) {
    if (i < suankiCubuk1) {

      lcd.setCursor(i+8,1);
      lcd.write((byte)i);
    } else {
      lcd.print(" ");
    }
    delay(15);
  }
}

void barDoldurma2(int kademe2) {
  const int kacBolme = 8; // 
  int suankiCubuk2 = kademe2 * kacBolme / 7;
  for (int i = 0; i < kacBolme; i++) {
     if (i < suankiCubuk2) {

      lcd.setCursor(i+8,0);
      lcd.write((byte)i);
    } else {
      lcd.print(" ");
    }
    delay(15);
  }
}