/*
Program vznikl na zaklade informaci na strankach
https://learn.sparkfun.com/tutorials/load-cell-amplifier-hx711-breakout-hookup-guide/all

Program pouziva knihovnu: https://github.com/bogde/HX711
                          https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
Knihovna je distribuovana pod GNU GENERAL PUBLIC LICENSE.

Program je volne k pouziti a autor neprebira zadnou zodpovednost za jeho pouziti.

Puvodni program řešil i kalibraci senzoru. Kalibracni hodnotu jsem zjistil pomoci prikladu pouziti prevodniku HX711, viz vyse.

Kalibraci jsem udelal tak, ze jsem bez zateze vahu vynuloval. Pak jsem vahu zatizil znamou 
hmotmosti a pomoci klavesy + a - jsem menil hodnotu kalibracni konstanty, az byla zobrazovana spravna vaha.
Protože ale kalibracni konstantu nikam neukladal, po zjisteni hodnoty jsem ji zapsal primo do programu.

Samotny program funguje tak, ze po zapnuti se zjisti zakladni hodnota,
ktera se dale pouziva jako hodnota pro nulovou vahu. V hlavni smycce se 120 x nacte hodnota
a zobrazi se prumerna hodnota. Testuje se stisk klavesy n nebo N a po stisku se provede stejna inicializace hodnoty 0
jako po zapnuti napajeni.

POZOR, PRI PROGRAMOVANI MUSI BYT BLUETOOTH MODUL ODPOJENY, PROTOZE PRO PROGRAMOVANI SE POUZIVAJI STEJNE PINY.

Arduino pin LCD:
            A5  - > SCL
            A4  - > SDA  
            5V  - > VCC
            GND - > GND
Arduino pin 2 -> HX711 CLK
             3 -> HX711 DOUT
             5V -> VCC
             GND -> GND

 Most any pin on the Arduino Uno will be compatible with DOUT/CLK.

 The HX711 board can be powered from 2.7V to 5V so the Arduino 5V power should be fine.
N - nulování
K - vstup do kalibrace,zjištění kalibrační konstanty
+ - zvyšování konstatnty
- - snižování konstatnty
S - zvyšení kroku konstaty +5
M - snížení kroku konstaty -5
E - konec kalibrace



*/

// LiquidCrystal I2C - Version: 1.1.2
#include <LiquidCrystal_I2C.h>
#include "HX711.h"
#define DOUT  3
#define CLK  2
#include <LiquidCrystal_I2C.h>

// nastavení adresy I2C (0x27 v mém případě),
// a dále počtu znaků a řádků LCD, zde 20x4
LiquidCrystal_I2C lcd(0x27, 16, 2);


HX711 scale;
float calibration_factor = 20636;
#define TIMES 20
//float avg_arr[TIMES];
float avg_val;  //float datový typ pro čísla s plovoucí destennou čárkou
int i, n;
int null_flag;
int stav;
int stepfactor;
int vahacal;

void setup() 
  {
  stepfactor = 50;
  Serial.begin(9600);
  lcd.init();// inicializuje displej
  lcd.backlight(); // zapne podsvětlení
  pinMode(12,INPUT);     // nastavení digi pinu 12 na vstupní
  lcd.clear();
  lcd.setCursor ( 0, 0 );
  lcd.print("N-nulovani");
  Serial.println ("N-nulovani");
  lcd.setCursor ( 0, 1 );
  lcd.print("K-kalibrace");
  Serial.println ("K-kalibrace");
  lcd.setCursor ( 0, 0);
  scale.begin(DOUT, CLK);
  
  CEKAM:   //čeká na Tlačítko a nebo na "N" z Bluetooth nebo na "K" z Bluetooth      
      char temp = Serial.read();
      if (digitalRead(12) == HIGH) goto DALE_1;

      // smyčka čekáni na nějaký znak 
      if (Serial.available() == 0)  
        { 
        goto CEKAM;
        } 
      // smyčka čekáni na nějaký znak 
      Serial.print("Prijato : ");
      Serial.println(temp);
      delay(500);     
      if(temp == 'N' || temp == 'n')
        {
              Serial.println("Jsem v N - nuluji");
              delay (2000);
              scale.set_scale();
              scale.tare(); //Reset the scale to 0
              long zero_factor = scale.read_average(); //Get a baseline reading
              scale.set_scale(calibration_factor); //Adjust to this calibration factor
              goto DALE_1;
        }
      //nová kalibrace, zjištení faktoru a jeho uložení
      if(temp == 'K' || temp == 'k')
        {
              Serial.println("jsem v K -kalibrace ");
              Serial.println("za 10sec vynuluji váhu ");
              delay (10000);
              //Nulování váhy
              scale.set_scale();                                          
              scale.tare();
              long zero_factor = scale.read_average(); //Get a baseline reading
              scale.set_scale(calibration_factor); //Adjust to this calibration factor
              //Nulování váhy
              lcd.clear();
              lcd.setCursor ( 0, 0 );
              lcd.print("+ nebo - ");
              Serial.println ("+ nebo - ");
              lcd.setCursor (0 , 1);
              lcd.print("S=fa+50, M=fa-50");
              Serial.println("S=fa+50, M=fa-50");
              Serial.println("E=konec kalibrace");
              Serial.print("pokracuji za 10sec");
              delay (10000);
                
      calznovu:
        char temp = Serial.read();
        scale.set_scale(calibration_factor); //Adjust to this calibration factor
        Serial.println("Reading: ");
        Serial.print(scale.get_units(3));         //přečte průměr z 3 odečtených hodnot z ADC mínus vlastní hmotnost, děleno
                                                 // parametrem SCALE nastaveným pomocí set_scale
        Serial.print(" kg"); //Change this to kg and re-adjust the calibration factor if you follow SI units like a sane person
        Serial.println(" calibration_factor: ");
        Serial.println(calibration_factor);
        Serial.println();
        delay(2000);
              // smyčka čekáni na nějaký znak 
              if (Serial.available() == 0)  { goto calznovu;} 
              // smyčka čekáni na nějaký znak 
                if(temp == '+' || temp == 'a')
                    {
                    Serial.println("jsem v + zmena kal.konstanty ");
                    delay(2000);
                    calibration_factor += stepfactor;
                    }
                if(temp == '-' || temp == '-')
                    {
                    Serial.println("jsem v - zmena kal.konstanty");
                    delay(2000);
                    calibration_factor -= stepfactor;
                    }
               if(temp == 'E' || temp == 'e') 
                    {
                    Serial.println("jsem v E end ukonceni kalibrace");
                    Serial.println("Budu nulovat váhu - odeberte zátěž");
                    Serial.println("Pro pokracování čekam na znak T ");
                    cistznovu:
                    char temp = Serial.read();
                      if(temp == 'T' )
                      {
                      goto DALE_1;  
                      }
                    goto cistznovu;  
                    delay(1000);
                    }
               
               if(temp == 'S' || temp == 's') 
                      {
                      Serial.println("jsem v S  zvyseni faktoru o +50");
                      stepfactor = stepfactor +50;
                      Serial.println("Factor = ");
                      Serial.println(stepfactor);
                       delay(2000);
                      }
               if(temp == 'M' || temp == 'm') 
                      {
                      Serial.println("jsem v M  snízení faktoru o -50");
                      stepfactor = stepfactor -50;
                      Serial.println("Factor = ");
                      Serial.println(stepfactor);
                      delay(2000);
                      }
        goto calznovu;
     }

goto CEKAM;      

DALE_1:
      
  lcd.clear();
  lcd.print ("Nulovani");
  Serial.println ("Nulovani");
  //HX711 :
  scale.begin(DOUT, CLK);
  scale.set_scale();
  scale.tare();                             //Nastavit vahu na 0
  long zero_factor = scale.read_average();  //nacti zakladni hodnotu
  scale.set_scale(calibration_factor);      //Nastav kalibracni hodnotu; řádek 52 > float calibration_factor = 22346;
  delay (300);
  lcd.clear();
  }


void loop() 
{
  {
  //pro zlepseni stability vypisovane hodnoty delam prumer ze 120 hodnot
  avg_val = 0.0;
    
  //xxxxxxxxxxxxxxxxxxxxxxxxxxx LOOP TIMES  120 průměrování čtené hodnoty z 120 hodnot xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    for(i = 0; i < TIMES; i++) 
    {
    avg_val += scale.get_units();   //scale.get_units () = momentální hodnota; funkce += je toto: avg_val = avg_val + scale.get_units()
      
    while (digitalRead(12) == HIGH)  // pokud se sepne tlačítko (připojí +5V na D12)provede se nulování váhy
      {   
      scale.set_scale();
      scale.tare();                                 //Reset the scale to 0
      long zero_factor = scale.read_average();      //Get a baseline reading
      scale.set_scale(calibration_factor);          //Adjust to this calibration factor
      //potrebuji zkratit cyklus, aby to reagovalo hned a nepsalo nesmysl
      null_flag = 1,
      i = TIMES;                                  //tady shodil nastavený cylus for i=0 to i=120 
      lcd.setCursor(0,1);
      lcd.clear();
      lcd.print("nulovani");
      delay (1000);
      lcd.clear();
      }
      char temp = Serial.read();
      if(temp == 'N' || temp == 'n')
          {
              char temp = Serial.read();
              scale.set_scale();
              scale.tare(); //Reset the scale to 0
              long zero_factor = scale.read_average(); //Get a baseline reading
              scale.set_scale(calibration_factor); //Adjust to this calibration factor
              lcd.setCursor(0,1);
              lcd.clear();
              lcd.print("nulovani");
              Serial.println ("nulovani");
              delay (1000);
              lcd.clear();
          }
    }
  //xxxxxxxxxxxxxxxxxxxxxxxxxxx LOOP TIMES  120  xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  }

  //pokud neprobehlo zrovna nulovani, vypisu zmerenou hodnotu
      if(!null_flag)  {          
                                //if(null_flag !=0) {         //když null_flag není rovný O
        //lcd.clear(); 
        lcd.setCursor ( 0, 0 );
        lcd.print ("VAHA: ");
        lcd.setCursor (0 , 1);
        //lcd.print ("                ");
        lcd.setCursor (0 , 1);
        lcd.print(avg_val / TIMES, 2);
        lcd.setCursor (8 , 1);
        lcd.print(" kg");
        Serial.print("VAHA: ");
        Serial.print(avg_val / TIMES, 2);
        Serial.print(" kg");
        Serial.println();
        
                        }
  null_flag = 0;

  
}