// Cronos Ukarumpa firmware C1


#include "msp430G2553.h"
#include "math.h"


//#define Clear 0x00
#define mod_but   BIT0// External buton definitions
#define plus_but  BIT1
#define minus_but BIT2
#define digit1 1   // Digit activation bits definitions
#define digit2 2
#define digit3 3
#define digit4 4
#define digit5 5
#define digit6 6
#define digit7 7
#define DT BIT5       // SP register bits definitions
#define CK BIT4
#define STROBE BIT3
#define RTC_CK BIT0   // RTC bits definitions
#define RTC_DT BIT1
#define digit_on 10000
#define ch0 0x3F      //display char definitions
#define ch1 0x06   // 0000 0110 pgfe dcba
#define ch2 0x5B   // 0101 1011
#define ch3 0x4F
#define ch4 0x66
#define ch5 0x6D
#define ch6 0x7C
#define ch7 0x07
#define ch8 0x7F
#define ch9 0x67   //  0110 0111
#define chA 0x5F   //  0101 1111
#define chB 0x7C   //  0111 1100
#define chC 0x58   //  0101 1000
#define chD 0x5E   //  0101 1110
#define chE 0x7B   //  0111 1011
#define chF 0x71   //  0111 0001
#define chG 0x6F   //  0110 1111
#define chH 0x74   //  0111 0100
#define chI 0x04   //  0000 0100
#define chJ 0x1E   //  0001 1110
#define chK 0x75   //  0111 0101
#define chL 0x38   //  0011 1000
#define chM 0x15   //  0001 0101
#define chN 0x54   //  0101 0100
#define chO 0x5C   //  0101 1100
#define chP 0x73   //  0111 0011
#define chQ 0x67   //  
#define chR 0x50   //  0101 0000
#define chS 0x6D   //  0110 1101
#define chT 0x78   //  0111 1000
#define chU 0x1C   //  0001 1100
#define chV 0x62   //  0110 0010
#define chX 0x52   //  0101 0010
#define chZ 0x5B   //  0101 1011
#define chY 0x6E   //  0110 1110
#define chW 0x2A   //  0010 1010
#define ch_ 0x08   //  0000 1000
#define chd 0x63   //  0110 0011  degree symbol
#define chc 0x39   //  0011 1001  celsius symbol
#define chq 0x80   //  1000 0000  DP used in text
#define clr  0x00  //  0000 0000
#define leds0 0x1F //  0001 1111  LEDs state sequences definition
#define leds1 0x1E //  0001 1110
#define leds2 0x1C //  0001 1100
#define leds3 0x18 //  0001 1000
#define leds4 0x10 //  0001 0000
#define leds5 0x00 //  0000 0000
#define leds6 0x1F //  0001 1111
#define leds7 0x1F //  0001 1111
#define leds8 0x1F //  0001 1111
#define leds9 0x1D //  0001 1101



float med1,med2,med3,med4,med5;
float med1t,med2t,med3t,med4t,med5t;
float temp_val_c,light_val_c,light_val,temp_val;
int ds1,ds2,ds3,ds4,ds5,ds6,ds7,Hz,Hu,Mz,Mu,Sz,Su,secset,minset,hset;
int n,a,k,delay,i,store,buton,store2,logo_count,sound_preset,Int_light,Int_temp;
int array_div_mod[4];
const unsigned char number_chars[10] = {ch0,ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,ch9}; 
const unsigned char led[10] = {leds0,leds1,leds2,leds3,leds4,leds5,leds6,leds7,leds8,leds9};
const unsigned char message1[40] = {clr,clr,clr,clr,clr,clr,chM,chI,chS,chS,chI,chN,chG,clr,chP,chA,chP,chU,chA,clr,chN,chE,chW,clr,chG,chU,chI,chN,chE,chA,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr};
const unsigned char message2[40] = {clr,clr,clr,clr,clr,clr,chT,chH,chE,clr,chL,chA,chN,chD,clr,chO,chF,clr,chU,chN,chE,chX,chP,chE,chC,chT,chE,chD,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr};
const unsigned char message3[40] = {clr,clr,clr,clr,clr,clr,chH,chO,chM,chE,clr,chO,chF,clr,ch8,ch3,ch9,clr,chL,chA,chN,chG,chU,chA,chG,chE,chS,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr};
const unsigned char message4[40] = {clr,clr,clr,clr,clr,clr,chB,chE,chS,chT,clr,chS,chN,chO,chR,chK,chE,chL,chI,chN,chG,clr,chE,chX,chP,chE,chR,chI,chE,chN,chC,chE,clr,clr,clr,clr,clr,clr,clr,clr};
const unsigned char message5[40] = {clr,clr,clr,clr,clr,clr,chH,chI,chK,chE,clr,chT,chH,chR,chO,chU,chG,chH,clr,chT,chH,chE,clr,chJ,chU,chN,chG,chL,chE,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr,clr};

float convert_light(int);   // Conversions
float convert_temp(int);
float bucla_div_mod(float);

int delay_time(int);        // delay related
int delay_long(int);

int repeated_start(int);    // RTC related
int slave_addr(int);
int start_condition(int);
int stop_condition(int);
int ACK_bit(int);
int RTC_read(int);
int RTC_write(int);
int write_bit(int);
int go_RTC_addr(int);
int debounce_mod(int);
int debounce_plus(int);
int debounce_minus(int);

int display_digit(int,int); //Clock related
int clock_set(int);
int adc_read (int);
int clock_display(int);

int logo(int);              // Other features
int display_dim(int);
int temp_display(int);
int beep_lf(int,int);

void main(void){
WDTCTL = WDTPW + WDTHOLD; // disable watch dog timer
DCOCTL = CALDCO_16MHZ; // set internal oscillator at 16MHz
BCSCTL1 = CALBC1_16MHZ; // set internal oscillator at 16MHz

P1OUT = 0x00;
P2OUT = 0x00;
P3OUT = 0x07; //0000 0111 keeps RTC reset off and the lines H
P1DIR = 0x38; //0011 1000
P2DIR = 0xFF;
P3DIR = 0xFF;
P3OUT = 0x07;

//--------------------config ADC
ADC10CTL1 |= INCH_6; //continuous sample mode, CH6 // CONSEQ1 + INCH_6
ADC10CTL0 |= ADC10SHT_2 + ADC10ON + MSC; //sample and hold time, adc on, cont. sample
ADC10AE0 |= 0x40; // select channel A6
ADC10CTL0 |= ADC10SC + ENC; // start conversions


//--------------------config PWM
P2SEL |= (BIT0);//P2.5 Select as TA1 output                  
TA1CCR0 = 1000;  
TA1CCR1 = 1000;
TA1CCR2 = 1000; 
TA1CCTL0 |= OUTMOD_7; //toggle
TA1CCTL1 |= OUTMOD_7; //toggle 
TA1CCTL2 |= OUTMOD_7; //toggle 
TA1CTL |= TASSEL_2 + MC_1; //smclk div/8 upmode.

sound_preset = 1;
logo_count = 1;



    for(;;) {      // ===================================================== Main loop ======================================
                                                            
   // adc_read(0);   // ---------------------------- ADC read light and temp 	


    store2 = P1IN;  // -------------------------------- Clock set loop entry
    buton = (store2 &= mod_but);       
    if(buton == 0 ){  clock_set(0); }
    
   
    store2 = P1IN;  // ----------------------------- Logo display loop entry
    buton = (store2 &= plus_but);       
    if(buton == 0 ){ 
      logo(logo_count); 
    }
    
    store2 = P1IN;  // ---------------------- Temperature display loop entry
    buton = (store2 &= minus_but);       
    if(buton == 0 ){
      temp_display(0); 
    }
    
    clock_display(0);
    
    if((Mu + Mz + Su + Sz) == 0){ // ---------- Logo display at certain time
      logo(logo_count); 
    }
    
                    
         }                  // ========================================== Main loop end ======================================           
}






//----------------------------------------------------------------------------------------------------------------------------------
//-----------------  Functions & procedures  -----------  Functions & procedures  -----------  Functions & procedures---------------
//----------------------------------------------------------------------------------------------------------------------------------


int clock_display(int){            // --------------------------------Clock display loop
    RTC_read(0); 
    ds1 = Hz;
    ds2 = Hu;
    ds3 = Mz;
    ds4 = Mu;
    ds5 = Sz;
    ds6 = Su; 
    ds7 = led[Sz];
                                   
    display_digit(number_chars[ds1],digit1);              
    display_digit(number_chars[ds2],digit2);             
    display_digit(number_chars[ds3],digit3);         
    display_digit(number_chars[ds4],digit4);                                
    display_digit(number_chars[ds5],digit5);              
    display_digit(number_chars[ds6],digit6);      
    display_digit(ds7,digit7);  
  return (0);
}



int display_dim(int){        // ---------------------------------- Display dimming procedure
  for(a=50;a>1;a--){  
  
//TA1CCR0 = 1000;  
TA1CCR1 = (a*20);
TA1CCR2 = (a*20); 

clock_display(0); 
adc_read(0);
  }
TA1CCR1 = 1000;
TA1CCR2 = 1000; 
  return (0);
}



int clock_set(int){      //----------------------------------------------- Clock set--------------------
    Su = 0x00;
    Sz = 0x00;
    minset = ((Mz * 10) + Mu);
    hset = ((Hz * 10) + Hu);
    debounce_mod(0);  
    beep_lf(100,1800);
    
    do{                   
    store2 = P1IN;
    buton = (store2 &= minus_but); 
    if(buton == 0 ){
    if (minset == 0)minset = 60;
    minset = minset - 1;
    debounce_minus(0);
    beep_lf(100,1800);
    }
                  
    store2 = P1IN;
    buton = (store2 &= plus_but); 
    if(buton == 0 ){
    minset = minset + 1;
    if (minset == 60) minset = 0;
    debounce_plus(0);
    beep_lf(100,1800);
    }
                             
    i=7; 
    store = minset;
    Mz = 0x00;
    Mu = 0x00;
    do{                   //  div/mod loop
      if (store >= 10){
      store = store - 10;  
      Mz = Mz + 1;
      }
      i--;
    }while(i != 0);
    Mu = store;
    
    ds3 = Mz;
    ds4 = Mu;
    ds6 = chT;
              
    display_digit(number_chars[ds3],digit3);
    display_digit(number_chars[ds4],digit4);                  
    display_digit(ds6,digit6);
    
    store2 = P1IN;
    buton = (store2 &= mod_but);                    
    }while(buton != 0 );
    
    debounce_mod(0);
    beep_lf(100,1800);
    do{    
      
    store2 = P1IN;
    buton = (store2 &= minus_but); 
    if(buton == 0 ){
    if (hset == 0)hset = 24;
    hset = hset - 1;
    debounce_minus(0);
    beep_lf(100,1800);
    }
    
    store2 = P1IN;
    buton = (store2 &= plus_but); 
    if(buton == 0 ){
    hset = hset + 1;
    if (hset == 24) hset = 0;
    debounce_plus(0);
    beep_lf(100,1800);
    }
     
    i=7; 
    store = hset;
    Hz = 0x00;
    Hu = 0x00;
    do{                   //  div/mod loop
      if (store >= 10){
      store = store - 10;  
      Hz = Hz + 1;
      }
      i--;
    }while(i != 0);
    Hu = store;
    
    ds1 = Hz;
    ds2 = Hu; 
    ds6 = chT;
             
    display_digit(number_chars[ds1],digit1);               
    display_digit(number_chars[ds2],digit2);             
    display_digit(ds6,digit6);
    
    store2 = P1IN;
    buton = (store2 &= mod_but);                    
    }while(buton != 0 );
    debounce_mod(0);
    beep_lf(100,1800);
    RTC_write(0);                
return (0);
}

int adc_read(int){      //------------------------------------------ ADC read light and temp --------------------
//--------------------------------------------------------------reading the temp
    ADC10CTL1 &= ~(INCH_7); //disable continuous sample mode,  CH7                 
    ADC10CTL1 |= INCH_6; //continuous sample mode, CH6
    ADC10AE0 |= 0x40; // select channel A6 //0100 0000
    ADC10CTL0 |= ADC10SC + ENC; // start conversions    
    delay_time(50);
    Int_temp = ADC10MEM;                      
//----------------------------------------------------------reading the light 
    ADC10CTL0 &= ~(ADC10SC + ENC); // stop conversions
    ADC10CTL1 &= ~(INCH_6); //disable continuous sample mode, CH6                         
    ADC10CTL1 |= INCH_7; //continuous sample mode, CH7
    ADC10AE0 |= 0x80; // select channel A7 //1000 0000
    ADC10CTL0 |= ADC10SC + ENC; // start conversions     
    delay_time(50);
    Int_light = ADC10MEM; 
    ADC10CTL0 &= ~(ADC10SC + ENC); // stop conversions
    
    temp_val_c = convert_temp(Int_temp);
    light_val_c = convert_light(Int_light);
            
//--------------------------------------------------------------average light
    if (Int_light > 0x00){
      med1 = med2;
      med2 = med3;    
      med3 = med4;
      med4 = med5;            
      med5 = light_val_c;   
      }
      light_val = (med1+med2+med3+med4+med5)/5;
    
//--------------------------------------------------------average temperature
    if (Int_temp > 0x00){
      med1t = med2t;
      med2t = med3t;    
      med3t = med4t;
      med4t = med5t;            
      med5t = temp_val_c;          
      }
      temp_val = (med1t+med2t+med3t+med4t+med5t)/5; 
 return (0);
} 


int RTC_read(int){      //------------------------------------------------ RTC_read---------------------

Sz = 0x00;
Su = 0x00;
Mz = 0x00;
Mu = 0x00;
Hz = 0x00;
Hu = 0x00;
  
  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  delay_time(10);
  start_condition(0);
  slave_addr(0);  
  write_bit(0);  // R/W bit is tet to Write
  ACK_bit(0);
  go_RTC_addr(0x00);
  ACK_bit(0);
  repeated_start(0);
  slave_addr(0);  
  write_bit(1);    // R/W bit is set to read
  ACK_bit(0);
  
  P3DIR = 0xFD;  //1111 1101 //DT in read mode
  delay_time(10);

  
  i = 4;
  do{
  Sz = Sz << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Sz &= 0xFE;  
  if ((P3IN & 0x02) > 0) Sz |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  Su = Su << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Su &= 0xFE;  
  if ((P3IN & 0x02) > 0) Su |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);
  
  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  write_bit(0);
  P3DIR = 0xFD;  //1111 1101 //DT in read mode  
   
  i = 4;
  do{
  Mz = Mz << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Mz &= 0xFE;  
  if ((P3IN & 0x02) > 0) Mz |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  Mu = Mu << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Mu &= 0xFE;  
  if ((P3IN & 0x02) > 0) Mu |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);

  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  write_bit(0);
  P3DIR = 0xFD;  //1111 1101 //DT in read mode  
   
  i = 4;
  do{
  Hz = Hz << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Hz &= 0xFE;  
  if ((P3IN & 0x02) > 0) Hz |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  Hu = Hu << 1;
  P3OUT |= RTC_CK;     
  delay_time(10);
  Hu &= 0xFE;  
  if ((P3IN & 0x02) > 0) Hu |= 0x01;
  P3OUT &= ~(RTC_CK); 
  delay_time(10);
  i--;
  }while (i!=0); 

  ACK_bit(0);
  stop_condition(0);  
return(0);
}



int RTC_write(int){      //------------------------------------------------ RTC_write--------------------
  
  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  delay_time(10);
  start_condition(0);
  slave_addr(0);  
  write_bit(0);  // R/W bit is tet to Write
  ACK_bit(0);
  go_RTC_addr(0x00);
  ACK_bit(0);
  
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Sz & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Sz = Sz << 1;
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Su & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Su = Su << 1;
  i--;
  }while (i!=0);
  
  write_bit(0);
   
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Mz & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Mz = Mz << 1;
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Mu & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Mu = Mu << 1;
  i--;
  }while (i!=0);
 
  write_bit(0); 
   
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Hz & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Hz = Hz << 1;
  i--;
  }while (i!=0);
  
  i = 4;
  do{
  P3OUT &= ~(RTC_DT); 
  if ((Hu & 0x08) > 0) P3OUT |= RTC_DT;
  P3OUT |= RTC_CK;     
  delay_time(10); 
  P3OUT &= ~(RTC_CK); 
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  Hu = Hu << 1;
  i--;
  }while (i!=0);

  ACK_bit(0);
  stop_condition(0);  
return(0);
}



int start_condition(int){      //------------------------------------RTC start condition---------------------
  delay_time(10);   
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  P3OUT &= ~(RTC_CK);  
  delay_time(10);
return (0);
}



int stop_condition(int){      //-------------------------------------RTC stop condition---------------------
  delay_time(10);
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT |= RTC_DT; 
  delay_time(10);
return (0);
}



int write_bit(int bit_val){      //-------------------------------------RTC Write bit---------------------
  if (bit_val == 0){
  P3OUT &= ~(RTC_DT); }
  else{
  P3OUT |= RTC_DT; 
  }
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
return (0);
}



int slave_addr(int){      //------------------------------------------RTC slave address--------------------
  i=2;
  do{
  P3OUT |= RTC_DT;   // Slave address 11
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT);  
  i--;
  delay_time(10);
  }while (i!=0);

  P3OUT &= ~(RTC_DT);   // Slave address 0
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT); 
  delay_time(10);
  
  P3OUT |= RTC_DT;  // Slave address 1
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT); 
   delay_time(10);

  i=3;
  do{
  P3OUT &= ~(RTC_DT);   // Slave address 000
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT);  
  i--;
  delay_time(10);
  }while (i!=0);
return (0);
}



int repeated_start(int){      //--------------------------------------RTC repeated start---------------------
  P3OUT |= RTC_DT;  
  delay_time(10);
  P3OUT |= RTC_CK;  
  delay_time(10);
  P3OUT &= ~(RTC_DT); 
  delay_time(10);  
  P3OUT &= ~(RTC_CK);
  delay_time(10);
return (0);
}



int ACK_bit(int){      //-------------------------------------------------RTC ACK bit---------------------
  P3DIR = 0xFD;  //1111 1101 //DT in read mode
  P3OUT |= RTC_CK;    //ACK bit
  delay_time(30);
  // if DT = 0 ...test bit
  P3OUT &= ~(RTC_CK); 
  P3DIR = 0xFF;  //1111 1111 //DT in write mode  
  delay_time(10);
return (0);
}



int go_RTC_addr(int addr){      //-------------------------------Go to speciffic RTC address---------------------
  P3OUT &= ~(RTC_DT); 
  i=8;
  do{
  if ((addr & 0x80) != 0) P3OUT |= RTC_DT; 
  P3OUT |= RTC_CK; 
  delay_time(10);
  P3OUT &= ~(RTC_CK);   
  P3OUT &= ~(RTC_DT);  
  addr = addr << 1;
  i--;
  delay_time(10);
  }while (i!=0);    
return (0);
}



int delay_time (int delay){      //----------------------------------------- Delay---------------------
  do delay--;
  while (delay != 0);
return (int)(delay);
}



int delay_long (int){            //--------------------------------------- Delay long------------------
  int j;                   
  j = 100;
  do{	
  delay_time(5000);
  j--;
  }while (j != 0);        
return (0);
}



int debounce_mod(int){      //------------------------------------- Debounce the mod button--------------------
 do{                 
 store2 = P1IN;
 buton = (store2 &= mod_but);
 delay_time(1000);
 }while (buton == 0);
return (0);
}



int debounce_minus(int){      //----------------------------------- Debounce the minus button--------------------
 do{                 
 store2 = P1IN;
 buton = (store2 &= minus_but);
 delay_time(1000);
 }while (buton == 0);
return (0);
}



int debounce_plus(int){      //------------------------------------ Debounce the plus button--------------------
 do{                 
 store2 = P1IN;
 buton = (store2 &= plus_but);
 delay_time(1000);
 }while (buton == 0);
return (0);
}



int display_digit(int w_char,int digit){  //------------------------------ Display digit ------------------------
int str;

P2OUT = 0x00;  
str = w_char; 
//---------------------------------------register load  
  
  if ((str & 0x80) != 0){  //Write str bit7 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT); 
  
  if ((str & 0x40) != 0){  //Write str bit6 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  if ((str & 0x20) != 0){  //Write str bit5 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT); 
  
  if ((str & 0x10) != 0){  //Write str bit4 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  if ((str & 0x08) != 0){  //Write str bit3 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT); 
  
  if ((str & 0x04) != 0){  //Write str bit2 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  if ((str & 0x02) != 0){  //Write str bit1 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  if ((str & 0x01) != 0){  //Write str bit0 in the SP register
  P1OUT |= DT;
  } 
  else {
  P1OUT &= ~(DT); 
  }
  P1OUT |= CK;
  P1OUT &= ~(CK); 
  P1OUT &= ~(DT);
  
  P1OUT |= STROBE;
  delay_time(10);
  P1OUT &= ~(STROBE);  

  if (digit == 7){
  P3OUT |= 0x10;
  delay_time(digit_on);
  P3OUT &= ~(0x10);  //0001 0000
  }
  else{
  P2SEL  |= (1 << (digit-1));//P2.5 Select as TA1 output 
  delay_time(digit_on);
  P2SEL =0x00;
  }
return(0);      
}   



float convert_temp (int Int_temp){         // ----------------------------Convert temp
float temp1,Ua1,r1_tb,r2_tb,t2k,rdiv;
    rdiv = 9900;
    r1_tb = 10500;
    
    Ua1 = (3.4/1024*Int_temp);
    r2_tb = (3.4*rdiv/Ua1-rdiv);   //r2 = vcc*rdiv/uADCin -rdiv
    if (r2_tb == r1_tb ){r2_tb++;} // prevents log(1)
    
    t2k=((298.16*3380)/log(r1_tb/r2_tb))/(3380/log(r1_tb/r2_tb)-298.16);  
    //T2= T1*B/ln(R1/R2)  /  ( B/ln(R1/R2) - T1 )   in Kelvin
    temp1 = t2k - 273.16 ;
return (float)(temp1);
} 



float convert_light (int Int_light){           // ------------------------Convert light
float light1,ua2,raport_divizor,r2,r1;
   
    r1 = 10000;
    r2 = 1000;
    ua2 = (3.33/1024*Int_light);
    raport_divizor = ((r1+r2)/r2);                                     
    light1 = (ua2*raport_divizor); 
return (float)(light1);
}



int logo(int message){             // ---------------------------------- Displaying Logos
  beep_lf(100,1800);
  display_dim(0);  
  
  for(a=0;a<39;a++){
    for(n=0;n<20;n++){  //n is the reversed constant of transition speed
      for(k=0;k<6;k++){
        if ( message == 1 ){    
          display_digit(message1[k+a],(k+1)); }     
        if ( message == 2 ){    
          display_digit(message2[k+a],(k+1)); }  
        if ( message == 3 ){    
          display_digit(message3[k+a],(k+1)); }     
        if ( message == 4 ){    
          display_digit(message4[k+a],(k+1)); }
        if ( message == 5 ){    
          display_digit(message5[k+a],(k+1)); }  
      }
    display_digit(led[0],digit7);  
    }
  }
      logo_count ++;
      if(logo_count > 5){
      logo_count = 0x01; 
      }
return(0);  
}



int temp_display(int){         // ---------------------------------- Displaying Temperature
  beep_lf(100,1800);
  display_dim(0);  
   for(a=0;a<50;a++){
      for(k=0;k<6;k++){
        display_digit(clr,(k+1));
      }
   }
bucla_div_mod(temp_val);
    ds1 = array_div_mod[0];
    ds2 = array_div_mod[1];
    ds3 = array_div_mod[2];
  
 for(a=0;a<200;a++){                                  
    display_digit(number_chars[ds1],digit1);         
    display_digit(number_chars[ds2],digit2);            
    display_digit(number_chars[ds3],digit3);         
    display_digit(clr,digit4);                                
    display_digit(chd,digit5);              
    display_digit(chc,digit6);      
    display_digit(led[9],digit7);
 }
  for(a=0;a<50;a++){
    for(k=0;k<6;k++){
      display_digit(clr,(k+1));
    }
 }
return(0);
}



float bucla_div_mod(float ref_temp_val){   //---------------------------- Loop for div/mod ------------
unsigned char j;
  
for(i=0; i<4; i++){
array_div_mod[i] = 0x00;          
}
    for(j=0; j<4; j++){ 
     if(j > 0){ 
     ref_temp_val = ref_temp_val*10;
     }
     for(i=0; i<10; i++){
     if ( ref_temp_val >= 10 ){
     ref_temp_val = ref_temp_val - 10;
     array_div_mod[j] ++;
     }
     } 
    }
         
return (int)(array_div_mod);                     
}

     
int beep_lf(int beep_l,int beep_f){            //   --------------------beep procedure-------------
    if (sound_preset > 0){
    beep_l = (beep_l*sound_preset);
    beep_f = (beep_f/sound_preset);  
    do{  
      P3OUT |= BIT3;       // beeper = 1                  
      delay_time(beep_f); 
      P3OUT &= ~(BIT3);    // beeper = 0   
      delay_time(beep_f); 
      beep_l--;
    }while(beep_l != 0);
    }   
return(0);
}