#include "IO-reg.h"
#include "intr6811.h"
#include "X25128.h"
#include "menu.h"
#include "ds1820.h"
#include "LCD.h"

char last_path[8];
char nbr_of_thermos[2];

/*
  Väntfunktion
  microsecs = 0x01 ger puls på 25 microsek.
  microsecs = 0x02 ger puls på 35 microsek.
  etc...
*/
monitor void ds1820_wait(char microsecs){
  char i;
  for(i=0x01; i<microsecs; i++);
}

/*
  Returnerar antalet termometrar som hittades
  under find_slave()-anropet, denna funktion kan
  alltså inte anropas förrän find_slave() har körts
  igenom.
*/
char ds1820_nbr_of_thermos(void){
  return nbr_of_thermos[0];
}

/*
  Läser en bit från termometrarna, används
  enbart internt.
*/
monitor char ds1820_read_bit(void){
  char i;
  PACTL |= 0x08;
  PACTL &= ~0x08;
  i = 1;              //För att klara längre sladdar krävs en kort 
fördröjning.
  i = 2;
  i = 3;
  if(PORTA & 0x02)
    return 0x01;
  else
    return 0x00;
}

/*
  Läser en hel byte från termometrarna, används
  enbart internt.
*/
char ds1820_read_byte(void){
  char i;
  char byte;
  byte = 0x00;
  for(i=0x01; i<=0x80 && i != 0x00; i+=i){
    if(ds1820_read_bit())
      byte |= i;
  }
  return byte;
}

/*
  Skriver en bit till termometrarna, används
  enbart internt.
*/
monitor void ds1820_write_bit(char bit){
  if(bit){
    PACTL |= 0x08;
    PACTL &= ~0x08;
  }
  else{
    PACTL |= 0x08;
    ds1820_wait(2);  //Pulsen skall vara 30 (15-60) microsek.
    PACTL &= ~0x08;
  }
}

/*
  Skriver en byte till termometrarna, används
  enbart internt.
*/
void ds1820_write_byte(char byte){
  char i;
  for(i=0x01; i<=0x80 && i != 0x00; i+=i){
    ds1820_write_bit(byte & i);
  }
}

/*
  Skickar resetsignal till termometrarna.
*/
monitor void ds1820_reset(void){
  PACTL |= 0x08;
  ds1820_wait(47);
  PACTL &= ~0x08;
  ds1820_wait(0x18);
}

/*
  Initierar termometrarna. Måste anropas för att
  kunna använda de andra funktionerna.
*/
void init_ds1820(void){
  char i;
  char address[2];
  char nbr_of_thermos_last_time[2];
  for(i=0; i<8; i++)
    last_path[i] = 0x00;
  PORTA = 0x00;
  address[0] = 0x00;
  address[1] = 0x00;
  X25128_read_data(nbr_of_thermos_last_time, 1, address);
  ds1820_find_slave();
  if(nbr_of_thermos_last_time[0] != nbr_of_thermos[0])
    X25128_reset_mem();
}

/*
  Letar efter termometrar, lagrar deras ID-nummer i
  minnet med start på plats 0x0001, antalet funna
  termometrar skrivs på plats 0x0000 och returneras.
  Namn på temometrarna lagras dessutom direkt efter
  ID-numrena i minnet, varje namn tar 14 bytes.
*/
void ds1820_find_slave(void){
  char serial_number[9];
  char address[2];
  char read_bit1;
  char read_bit2;
  char i;
  char j;
  char k;
  char m;
  char address_to_nbr_of_thermos[2];
  nbr_of_thermos[0] = 0;
  nbr_of_thermos[1] = 0xFF;
  address[0] = 0x00;
  address[1] = 0x01;
  address_to_nbr_of_thermos[0] = 0x00;
  address_to_nbr_of_thermos[1] = 0x00;
  i=7;
  while(last_path[i] == 0x00 && i != 0xFF)
    i--;
  do{
    j=0x80;
    while((j!=0x01 && ((j & last_path[i]) == 0x00)))
      j=j/2;
    for(k=0x00; k<0x08; k++)
      serial_number[k] = 0x00;
    serial_number[8] = 0xFF;
    ds1820_reset();
    ds1820_write_byte(0xF0);
    ds1820_wait(5);
    for(k=0x00; k<0x08; k++){
      for(m=0x01; m<=0x80 && m != 0x00; m+=m){
        read_bit1 = ds1820_read_bit();
        ds1820_wait(1);
        read_bit2 = ds1820_read_bit();
        if(read_bit1){
          if(read_bit2)
            ;                          //11
            //ERROR No devices!!
          else{
            serial_number[k] |= m;     //10
            ds1820_write_bit(0x01);
          }
        }
        else{
          if(read_bit2){               //01
            ds1820_write_bit(0x00);
          }
          else{
            if(k==i && m==j){          //00
              ds1820_write_bit(0x00);
              last_path[k] &= ~m;
            }
            else{
              ds1820_write_bit(0x01);
              serial_number[k] |= m;
              last_path[k] |= m;
            }
          }
        }
      }
    }
    i=7;
    while((last_path[i] == 0x00) && i != 0xFF)
      i--;
    nbr_of_thermos[0]++;
    X25128_write_data(serial_number, address, 8);
    if(address[1] + 8 < address[1])
      address[0] += 1;
    address[1] += 8;
  }while(i != 0xFF);
  X25128_write_data(nbr_of_thermos, address_to_nbr_of_thermos, 1);
}

/*
   ber alla term,ometrar att konvertera temperaturen.
   Efteråt är det bara att anropa ds1820_read_temp för
   att få alla temperaturer (efter tillräckligt lång paus).
*/
void ds1820_preread_temp(void){
  ds1820_reset();
  ds1820_write_byte(0xCC);          //Skip ROM
  ds1820_write_byte(0x44);          //Convert Temp
}

/*
   läser in heltals-infon och sparar den i
   temp_data[0 och 1]. Om inte read_complement anropas
   efteråt, så ska reset anropas direkt efter.
*/
void ds1820_read_temp(char temp[], char id[], char nbr){
  char i;
  ds1820_reset();
  ds1820_write_byte(0x55);          //Match ROM
  for(i=0; i<8; i++)
    ds1820_write_byte(id[i]);
  ds1820_write_byte(0xBE);          //Read Scratchpad
  for(i=0; i<0x02; i++)
    temp[i] = ds1820_read_byte();

  ds1820_read_complement(temp, nbr);
}

/* läser in decimal-infon och sparar den i
   temp_data[2 och 3]. Subrutinen kan endast
   anropas direkt efter read_temp anropats.
   Denna funktion sparar dessutom det inlästa
   värdet på minnet. nbr är termometerns nummer
   som börjar på 0.
*/
void ds1820_read_complement(char temp_data[], char nbr){
  char i;
  char address[2];
  int tmp;
  char max_value[4];
  char min_value[4];
  int int_max[2];
  int int_min[2];
  int int_current[2];
  for(i=0; i<0x04; i++)
    ds1820_read_byte();
  for(i=2; i<0x04; i++)
    temp_data[i] = ds1820_read_byte();
  ds1820_reset();
  tmp = 1 + 8 * nbr_of_thermos[0] + 14 * nbr_of_thermos[0] + 4 * nbr;
  address[0] = tmp/256;
  address[1] = tmp%256;
  X25128_write_data(temp_data, address, 4);

  tmp = 1 + (8 + 14 + 4) * nbr_of_thermos[0] + 4 * nbr;
  address[0] = tmp/256;
  address[1] = tmp%256;
  X25128_read_data(min_value, 4, address);

  tmp = 1 + (8 + 14 + 4 + 4) * nbr_of_thermos[0] + 4 * nbr;
  address[0] = tmp/256;
  address[1] = tmp%256;
  X25128_read_data(max_value, 4, address);

  int_current[0] = ds1820_convert_temp(temp_data);
  int_max[0] = ds1820_convert_temp(max_value);
  int_min[0] = ds1820_convert_temp(min_value);

  tmp = 1 + (8 + 14 + 4 + 4) * nbr_of_thermos[0] + 4 * nbr;
  address[0] = tmp/256;
  address[1] = tmp%256;
  ds1820_convert_temp_decimals(max_value, int_max);
  ds1820_convert_temp_decimals(temp_data, int_current);
  if((int_current[0] > int_max[0]) ||
     ((int_current[0] == int_max[0]) && int_current[1] > int_max[1]))
    X25128_write_data(temp_data, address, 4);

  tmp = 1 + (8 + 14 + 4) * nbr_of_thermos[0] + 4 * nbr;
  address[0] = tmp/256;
  address[1] = tmp%256;
  ds1820_convert_temp_decimals(min_value, int_min);
  if((int_current[0] < int_min[0]) ||
     ((int_current[0] == int_min[0]) && int_current[1] < int_min[1]))
    X25128_write_data(temp_data, address, 4);

  ds1820_reset();
}

/*
  returnerar heltalsdelen av temperaturen, som beräknas
  mha temp_data[0 och 1].
*/
int ds1820_convert_temp(char temp_data[]){
  int signed_temp;
  if(temp_data[1])
    signed_temp = (-256 + temp_data[0])/2;
  else
    signed_temp = temp_data[0]/2;
  return signed_temp;
}

/* lagrar decimaldelen av temperaturen i temp[1], som
   beräknas mha temp_data[2 och 3]. Ändrar även temp[0]
   om decimaldelen understiger 0 eller överstiger 100.
*/
void ds1820_convert_temp_decimals(char temp_data[], int temp[]){
  char taljare;
  char namnare;
  taljare = temp_data[3] - temp_data[2];
  namnare = temp_data[3];

  temp[1] = 10 * (taljare * 10 / namnare);
  taljare = 10 * taljare - ((temp[1]/10) * namnare);
  temp[1] += (taljare * 10 / namnare);
  taljare = 10 * taljare - ((temp[1]%10) * namnare);
  if((taljare * 10 / namnare) >= 5)
    temp[1] += 1;

  temp[1] -= 25;
  if(temp[1] < 0){
    temp[0] -= 1;
    temp[1] = 100 + temp[1];
  }
  else if(temp[1] > 99){
    temp[0] += 1;
    temp[1] -= 100;
  }
}

/*
  Kopierar de senaste lästa värdena till loggen i minnet
*/
void ds1820_logg_values(void){
  char last_address[2];
  char new_address[2];
  char address[2];
  char temp_data[4];
  char i;
  int tmp;

  tmp = 1 + (8 + 14 + 4*4) * nbr_of_thermos[0];
  address[0] = tmp/256;
  address[1] = tmp%256;
  X25128_read_data(last_address, 2, address);

  for(i=0; i<nbr_of_thermos[0]; i++){
    if(new_address[1] + 4 < new_address[1]){
      new_address[1]++;
      if(new_address[0] + 1 < new_address[0]){
        tmp = 1 + (8 + 14 + 4*4) * nbr_of_thermos[0] + 2 + 1 + 2;
        new_address[0] = tmp/256;
        new_address[1] = tmp%256;
      }
      else
        new_address[0]++;
    }
    else
      new_address[1]++;

    tmp = 1 + (8 + 14) * nbr_of_thermos[0] + 4*i;
    address[0] = tmp/256;
    address[1] = tmp%256;
    X25128_read_data(temp_data, 4, address);
    X25128_write_data(temp_data, new_address, 4);

    last_address[0] = new_address[0];
    last_address[1] = new_address[1];
  }

  tmp = 1 + (8 + 14 + 4*4) * nbr_of_thermos[0];
  address[0] = tmp/256;
  address[1] = tmp%256;
  X25128_write_data(last_address, address, 2);
}

void ds1820_read_all_temps(void){
  char temp_data[4];
  int temp[2];
  char address[2];
  char id[8];
  char i;
  char j;
  address[0] = 0x00;
  address[1] = 0x01;

  for(i=0; i<nbr_of_thermos[0]; i++){
    ds1820_preread_temp();
  }

  for(j=0; j<200; j++)
    ds1820_wait(255);

  for(i=0; i<nbr_of_thermos[0]; i++){
    X25128_read_data(id, 8, address);

    ds1820_read_temp(temp_data, id, i);

    temp[0] = ds1820_convert_temp(temp_data);      //lägger heltalsdelen av 
temperaturen i temp[0]
    ds1820_convert_temp_decimals(temp_data, temp); //lägger decimaldelen av 
temperaturen i temp[1]
    if(address[1] + 8 < address[1])
      address[0] += 1;
    address[1]+=8;
  }
}