/****************************************************************/
/*								*/
/* Remote Environmental Monitoring and Control via Internet 	*/
/* Daniel John McAuley						*/
/* Level 4 1999/2000						*/
/*								*/
/* NAME:	control.c					*/
/* FUNCTION:	Initial test program for establishing		*/
/*		proper operation, communication and control	*/
/*		of the microcontroller				*/
/* DEVICE:	For use with Microchip 16F876.			*/
/* 								*/
/* NOTES:	Compiler PIC C does not seem to like comments	*/
/*		on the same line as the device specification	*/
/*								*/
/*		Use hyperterminal 9600,8,1,N for debug comms	*/
/*								*/
/* TODO		Use interrupt serial comms			*/
/*		Error handling					*/
/*		Use watchdog					*/
/*								*/
/* NOTE		Code could do with a clean-up!			*/
/* 								*/
/* 								*/
/****************************************************************/

#include <string.h>
#include <math.h>
#include <16c76.h>


#device PIC16C76
#use delay(clock = 4000000)		/* Clock speed */
#use fast_io(A)
					/* DEFINE ADDRESSES*/

#byte PORTA =  5
#byte PORTB =  6
#byte PORTC =  7			/* PortC address 7h */
#byte RCSTA = 0X18			/* Receive Status and Control Reg  */
#byte TXSTA = 0X98			/* Transmit Status and Control Reg */
#byte SPBRG = 0X99			/* Serial Port Baud Rate Gen. Reg  */
#byte TXREG = 0X19			/* USART Transmit data register */
#byte RCREG = 0x1A			/* USART Receive data register  */
#byte PIR1 = 0X0C			/* PIR1 register - used for tx and rx buffer status */


#define TXIF 4				/* USART Transmit Interrupt Flag - Bit 4 of PIR1 */
#define RCIF 5				/* USART Receive Interrupt Flag - Bit 5 of PIR1 */
#define DELAY_TIME 1			/* Specify a delay time of 5 */
#define MESSAGE_SIZE 16
#define NO_COMMANDS 16			/* Specify the number of user commands */
#define CMD_SIZE 10			/* Specify the fixed size of data field */
#define rx_ready bit_test(PIR1,RCIF)	/* Handy function alias */



					/* CONSTANT MESSAGES */
char const msg[110] = 
   {'N','E','T','C','O','N',' ','T','e','c','h','n','o','l','o','g','y','.','.','.','.'};


					/* GLOBALS */
static char my_address[2] = {'0','1'};
static char resp_header[4] = {'0','0','0','1'};
static char mess_buff[MESSAGE_SIZE];
static char resp_buff[MESSAGE_SIZE];
static char dest_address[2];
static char src_address[2];
static char data[10];
static char temp[2];
					/* FLAGS */
int message_received = 0;

					/* FUNCTION PROTOTYPES */
int init_USART(void);
void poll_and_receive(void);
void gen_output_buff(char *buffer, int buff_size);
void extract_address(char *buffer);
void extract_data(char *buffer);
int str_compare(char *string1,char *string2, int size);
int id_fn_do_cmd(void);
void flush_buffer(char * buffer, int size);

// DS1820 1-wire prototypes
void _1w_init(int sensor);
int _1w_in_byte(int sensor);
void _1w_out_byte(int d, int sensor);
void _1w_pin_hi(int sensor);
void _1w_pin_low(int sensor);
#separate
void _Read_temp(void);



					/* MAIN */
main()
{ 
  int cmd_code,i=0;
  signed int result = -1;
  char temp_buff[10];
   
  char no_msg[16] = {'M','s','g',' ','n','o','t',' ','f','o','r',' ','m','e','\r'}; 

  
  init_USART();  			/* Initialise the USART */
  for (i=0; i<21;i++)			/* Output the greeting */
  { 
	TXREG = msg[i]; 
        delay_ms(DELAY_TIME);
  } 
 
 i=0;

 while(1){				/* Loop */
   poll_and_receive();			/* Poll the serial receive reg to determine when char rx */
   
   if (message_received == 1 ){		/* If a message is received */

     extract_address(mess_buff);	/* Extract the destination and source addresses */
 
     if((dest_address[0] == my_address[0]) && (dest_address[1] == my_address[1])){

       extract_data(mess_buff);

       message_received = 0;

       id_fn_do_cmd();			/* Call the main identification and action fn */

    }

    else{
       gen_output_buff(no_msg,16);	/* Otherwise output that message not for me! */
       message_received = 0;
    }

   }

 }
}


/************************************************************************************************/
/*												*/
/* 					      FUNCTIONS 					*/
/*												*/
/************************************************************************************************/


/************************************************************************************************/

init_USART()			
{
PORTC = 0;				
SET_TRIS_C(0Xc0);
PORTB = 0;
SET_TRIS_B(0xF);
PORTA = 0;
SET_TRIS_A(0x00);
RCSTA = 0X90;
TXSTA = 0X24;
SPBRG = 25;
return(0);
}

/************************************************************************************************/

poll_and_receive()
{

int i,ch;

if (rx_ready){ 			/* Wait until there is a char in receive buffer */
 ch = RCREG;			/* Get character from receive reg */
        
 switch (ch){			/* Look at received character */
				
   case '*':			/* If it is the chosen SOT char '*' in this case */
   {
	bit_set(PORTC,0);	/* Turn Rx LED ON */
     mess_buff[0] = ch;		/* Save SOT in mess_rx array */	   
 
				/* save the rest of the incoming fixed-length message */

     for(i=1;i<MESSAGE_SIZE;i++){
	while(!rx_ready){	/* Wait on the rxbuffer */
	}
	
	mess_buff[i] = RCREG;	/* Save in mess_rx array */

	delay_ms(DELAY_TIME);	/* Delay */
	bit_clear(PORTC,0);	/* Turn RX LED OFF */
     }
     message_received = 1;	/* Set flag */
   }

   default:			/* Default do nothing */
   {
   }

 }
}
}


/************************************************************************************************/

gen_output_buff(char *buffer, int buff_size)
{

int i=0;
bit_set(PORTC,1);
for(i=0;i<buff_size;i++){
  TXREG = buffer[i];
  delay_ms(DELAY_TIME);
}
bit_clear(PORTC,1);
}  



/************************************************************************************************/

extract_address(char *buffer)
{

int i,j=0;

for(i=1;i<3;i++){
dest_address[j] = buffer[i];
j++;
}
j=0;
for(i=3;i<5;i++){
src_address[j] = buffer[i];
j++;
}

}


/************************************************************************************************/

extract_data(char *buffer)
{

int i,j=0;

for(i=5;i<15;i++){
data[j] = buffer[i];
j++;
}

}

/************************************************************************************************/

str_compare(char *string1,char *string2, int size)
{

int i=0;

 for(i=0;i<size;i++){
  if(string1[i] != string2[i]){
  return(-1);
  }
 }

return(0);
}

/************************************************************************************************/

id_fn_do_cmd()
{
signed int result =  5;				/* result equal to 5, unused initialiser */
char * new;
char compare_buffer[CMD_SIZE];
char temp_buffer[CMD_SIZE];
/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_0_RD");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

 if (bit_test(PORTB,0))				/* If Pin 0 on port B is high */
 {
 strcpy(resp_buff,"*0001R_PTB_0_ON#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 if (!bit_test(PORTB,0))			/* If Pin 0 on port B is low */
 {
 strcpy(resp_buff,"*0001R_PTB_0_OF#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_1_RD");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

 if (bit_test(PORTB,1))				/* If Pin 1 on port B is high */
 {
 strcpy(resp_buff,"*0001R_PTB_1_ON#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 if (!bit_test(PORTB,1))			/* If Pin 1 on port B is low */
 {
 strcpy(resp_buff,"*0001R_PTB_1_OF#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }
 
 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_2_RD");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

 if (bit_test(PORTB,2))				/* If Pin 2 on port B is high */
 {
 strcpy(resp_buff,"*0001R_PTB_2_ON#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 if (!bit_test(PORTB,2))			/* If Pin 2 on port B is low */
 {
 strcpy(resp_buff,"*0001R_PTB_2_OF#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_3_RD");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

 if (bit_test(PORTB,3))				/* If Pin 0 on port B is high */
 {
 strcpy(resp_buff,"*0001R_PTB_3_ON#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 if (!bit_test(PORTB,3))			/* If Pin 0 on port B is low */
 {
 strcpy(resp_buff,"*0001R_PTB_3_OF#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_4_RD");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

 if (bit_test(PORTB,4))				/* If Pin 4 on port B is high */
 {
 strcpy(resp_buff,"*0001R_PTB_4_ON#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 if (!bit_test(PORTB,4))			/* If Pin 4 on port B is low */
 {
 strcpy(resp_buff,"*0001R_PTB_4_OF#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_5_RD");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

 if (bit_test(PORTB,5))				/* If Pin 5 on port B is high */
 {
 strcpy(resp_buff,"*0001R_PTB_5_ON#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 if (!bit_test(PORTB,5))			/* If Pin 5 on port B is low */
 {
 strcpy(resp_buff,"*0001R_PTB_5_OF#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_6_RD");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

 if (bit_test(PORTB,6))				/* If Pin 6 on port B is high */
 {
 strcpy(resp_buff,"*0001R_PTB_6_ON#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 if (!bit_test(PORTB,6))			/* If Pin 6 on port B is low */
 {
 strcpy(resp_buff,"*0001R_PTB_6_OF#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_7_RD");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

 if (bit_test(PORTB,7))				/* If Pin 7 on port B is high */
 {
 strcpy(resp_buff,"*0001R_PTB_7_ON#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 if (!bit_test(PORTB,7))			/* If Pin 7 on port B is low */
 {
 strcpy(resp_buff,"*0001R_PTB_7_OF#");
 gen_output_buff(resp_buff,MESSAGE_SIZE);
 }

 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_4_ON");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){
  if (bit_test(PORTB,4))			/* If Pin 4 on port B is already ON */
  {
   strcpy(resp_buff,"*0001R_PTB_4_ON#");
   gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Return message saying it is ON */
   return(0);
  }

  if (!bit_test(PORTB,4))			/* If Pin 4 on port B is OFF */
  {
   bit_set(PORTB,4);				/* Turn it ON */
   if(bit_test(PORTB,4))			/* Check to make sure it is on */
   {
    strcpy(resp_buff,"*0001R_PTB_4_ON#");
    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Output message saying it is ON */
    return(0);					/* Need case if u issue ON cmd but doesnt turn on?? */
   }
  }

 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_5_ON");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

  if (bit_test(PORTB,5))			/* If Pin 5 on port B is already ON */
  {
   strcpy(resp_buff,"*0001R_PTB_5_ON#");
   gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Return message saying it is ON */
   return(0);
  }

  if (!bit_test(PORTB,5))			/* If Pin 5 on port B is OFF */
  {
   bit_set(PORTB,5);				/* Turn it ON */
   if(bit_test(PORTB,5))			/* Check to make sure it is on */
   {
    strcpy(resp_buff,"*0001R_PTB_5_ON#");
    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Output message saying it is ON */
    return(0);					/* Need case if u issue ON cmd but doesnt turn on?? */
   }
  }
 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_6_ON");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

  if (bit_test(PORTB,6))			/* If Pin 6 on port B is already ON */
  {
   strcpy(resp_buff,"*0001R_PTB_6_ON#");
   gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Return message saying it is ON */
   return(0);
  }

  if (!bit_test(PORTB,6))			/* If Pin 6 on port B is OFF */
  {
   bit_set(PORTB,6);				/* Turn it ON */
   if(bit_test(PORTB,6))			/* Check to make sure it is on */
   {
    strcpy(resp_buff,"*0001R_PTB_6_ON#");
    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Output message saying it is ON */
    return(0);					/* Need case if u issue ON cmd but doesnt turn on?? */
   }
  }
 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_7_ON");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

  if (bit_test(PORTB,7))			/* If Pin 7 on port B is already ON */
  {
   strcpy(resp_buff,"*0001R_PTB_7_ON#");
   gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Return message saying it is ON */
   return(0);
  }

  if (!bit_test(PORTB,7))			/* If Pin 7 on port B is OFF */
  {
   bit_set(PORTB,7); 				/* Turn it ON */

   if(bit_test(PORTB,7))			/* Check to make sure it is on */
   {
    strcpy(resp_buff,"*0001R_PTB_7_ON#");
    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Output message saying it is ON */
    return(0);					/* Need case if u issue ON cmd but doesnt turn on?? */
   }
  }
 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_4_OF");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

  if (!bit_test(PORTB,4))			/* If Pin 4 on port B is already OFF */
  {
   strcpy(resp_buff,"*0001R_PTB_4_OF#");
   gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Return message saying it is OFF */
   return(0);
  }

  if (bit_test(PORTB,4))			/* If Pin 7 on port B is ON */
  {
   bit_clear(PORTB,4);				/* Turn it OFF */
   if(!bit_test(PORTB,4))			/* Check to make sure it is OFF */
   {
    strcpy(resp_buff,"*0001R_PTB_4_OF#");
    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Output message saying it is OFF */
    return(0);					/* Need case if u issue OFF cmd but doesnt turn OFF?? */
   }
  }
 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_5_OF");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

  if (!bit_test(PORTB,5))			/* If Pin 5 on port B is already OFF */
  {
   strcpy(resp_buff,"*0001R_PTB_5_OF#");
   gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Return message saying it is OFF */
   return(0);
  }

  if (bit_test(PORTB,5))			/* If Pin 5 on port B is ON */
  {
   bit_clear(PORTB,5);				/* Turn it OFF */
   if(!bit_test(PORTB,5))			/* Check to make sure it is OFF */
   {
    strcpy(resp_buff,"*0001R_PTB_5_OF#");
    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Output message saying it is OFF */
    return(0);					/* Need case if u issue OFF cmd but doesnt turn OFF?? */
   }
  }
 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_6_OF");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

  if (!bit_test(PORTB,6))			/* If Pin 6 on port B is already OFF */
  {
   strcpy(resp_buff,"*0001R_PTB_6_OF#");
   gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Return message saying it is OFF */
   return(0);
  }

  if (bit_test(PORTB,6))			/* If Pin 6 on port B is ON */
  {
   bit_clear(PORTB,6);				/* Turn it OFF */
   if(!bit_test(PORTB,6))			/* Check to make sure it is OFF */
   {
    strcpy(resp_buff,"*0001R_PTB_6_OF#");
    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Output message saying it is OFF */
    return(0);					/* Need case if u issue OFF cmd but doesnt turn OFF?? */
   }
  }
 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_PTB_7_OF");
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

  if (!bit_test(PORTB,7))			/* If Pin 7 on port B is already OFF */
  {
   strcpy(resp_buff,"*0001R_PTB_7_OF#");
   gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Return message saying it is OFF */
   return(0);
  }

  if (bit_test(PORTB,7))			/* If Pin 7 on port B is ON */
  {
   bit_clear(PORTB,7);				/* Turn it OFF */
   if(!bit_test(PORTB,7))			/* Check to make sure it is OFF */
   {
    strcpy(resp_buff,"*0001R_PTB_7_OF#");
    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Output message saying it is OFF */
    return(0);					/* Need case if u issue OFF cmd but doesnt turn OFF?? */
   }
  }
 return(0);
}

/* -------------------------------------------------------------------------------------------- */
strcpy(compare_buffer, "C_DS_01_RD");		/* If read temp command */
result = str_compare(data,compare_buffer,CMD_SIZE);
if (result == 0){

    _Read_temp();				/* Call 1-wire read temperature fn */
    strcpy(resp_buff,"*0001R_DS_01_00#");	/* Copy response template */
    resp_buff[13] = temp[0];			/* Copy temp LSB to response */
    resp_buff[14] = temp[1];			/* Copy temp MSB to response */

    gen_output_buff(resp_buff,MESSAGE_SIZE);	/* Not implemented, example output for completeness */
 return(0);
}

/************************************************************************************************/


flush_buffer(char * buffer, int size)
{

int i=0;

for(i=0;i<size;i++){
 buffer[i] = '\0';
}

}
/************************************************************************************************/

/************************************************************************************************/
/*												*/
/* 				DALLAS DS1820 1-WIRE FUNCTIONS 					*/
/*												*/
/************************************************************************************************/


// The following are standard 1-Wire routines.
// sensor corresponds to the PORTA pin that the DS1820
// is connected to.



// Initialise
void _1w_init(int sensor)
{
   _1w_pin_hi(sensor);
   _1w_pin_low(sensor);
   delay_us(500);

   _1w_pin_hi(sensor);
   delay_us(500);
}


// Read in one byte from DS1820
int _1w_in_byte(int sensor)
{
   int n, i_byte, temp, mask;
   mask = 0xff & (~(0x01<<sensor));
   for (n=0; n<8; n++)
   {
      PORTA=0x00;
      SET_TRIS_A(mask);
      SET_TRIS_A(0xff);
#asm
      CLRWDT
      NOP
      NOP
#endasm
      temp=PORTA;
      if (temp & ~mask)
      {
        i_byte=(i_byte>>1) | 0x80;	// least sig bit first
      }
      else
      {
        i_byte=i_byte >> 1;
      }
      delay_us(60);
   }
   return(i_byte);
}


// write a byte to the DS1820
void _1w_out_byte(int d, int sensor)
{
   int n, mask;
   mask = 0xff & (~(0x01<<sensor));
   for(n=0; n<8; n++)
   {
      if (d&0x01)
      {
         PORTA=0;
         SET_TRIS_A(mask);		// momentary low
         SET_TRIS_A(0xff);
         delay_us(60);
      }

      else
      {
          PORTA=0;
          SET_TRIS_A(mask);
	  delay_us(60);
          SET_TRIS_A(0xff);
      }
      d=d>>1;
   }
}


// Put DS1820 DQ pin high
void _1w_pin_hi(int sensor)
{
   SET_TRIS_A(0xff);		
}

// Put DS1820 DQ pin low
void _1w_pin_low(int sensor)
{
   PORTA = 0x00;
   SET_TRIS_A(0xff & (~(0x01 << sensor)));
}


// Perform a read temperature process

#separate
void _Read_temp(void)
{

 int lsb,n,buff[2],sensor=0;	   // Sensor is 0 for PORTA Pin0 as required


      _1w_init(sensor);		
      _1w_out_byte(0xcc, sensor);  // skip ROM

      _1w_out_byte(0x44, sensor);  // perform temperature conversion
	

	while(_1w_in_byte(sensor) != 0xFF)
	 {
	 /* Wait here til temp conversion done */
	 }

      _1w_init(sensor);
      _1w_out_byte(0xcc, sensor);  // skip ROM

      _1w_out_byte(0xbe, sensor);  // read the result

      for (n=0; n<2; n++)
      {
         temp[n]=_1w_in_byte(sensor);	//Store in temp buffer
      }

      _1w_init(sensor);



}	


// END