#include <termios.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/signal.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>



#define BAUDRATE B9600
#define MODEMDEVICE "/dev/ttyACM0"
#define _POSIX_SOURCE 1         //POSIX compliant source
#define FALSE 0
#define TRUE 1

volatile int STOP=FALSE;

void signal_handler_IO (int status);    //definition of signal handler
int wait_flag=TRUE;                     //TRUE while no signal received
char devicename[80] = MODEMDEVICE;
int fd_glob;
long BAUD = B9600;                      // derived baud rate from command line
long DATABITS = CS8;
long STOPBITS = 0;
long PARITYON = 0;
long PARITY = 0;

FILE *input;
FILE *output;
int status;
unsigned char checksum(unsigned char*lpData, int nSize);
int check_valid(unsigned char*lpData, int nSize);
//unsigned char *pakket(unsigned char prio, unsigned char rtr, unsigned char lenght, unsigned char addres, unsigned char*lpData, unsigned char*dest);
int pakket(unsigned char prio, unsigned char rtr, unsigned char lenght, unsigned char addres, unsigned char*lpData);


main(int Parm_Count, char *Parms[])
{

   char Param_strings[7][80];
   char message[8];

   int fd, tty, c, res, i, error, pr, valid_string;
   char In1, Key;
   unsigned char In2, prio, rtr, lenght, addres;
   struct termios oldtio, newtio;       //place for old and new port settings for serial port
   struct termios oldkey, newkey;       //place tor old and new port settings for keyboard teletype
   struct sigaction saio;               //definition of signal action
   unsigned char buf[255];              //buffer for where data is put
  int sercmd, serstat,status;
   
   input = fopen("/dev/tty", "r");      //open the terminal keyboard
   output = fopen("/dev/tty", "w");     //open the terminal screen
//output = stdout;


   if (!input || !output)
   {
      fprintf(stderr, "Unable to open /dev/tty\n");
      exit(1);
   }

   error=0;
   
   //read the parameters from the command line
   if (Parm_Count==2)  //if there are the right number of parameters on the command line
   {
      for (i=1; i<Parm_Count; i++)  // for all wild search parameters
      {
         strcpy(Param_strings[i-1],Parms[i]);
      }
      i=sscanf(Param_strings[0],"%s",devicename);
      if (i != 1) error=1;
      
   }  //end of if param_count

      sprintf(message,"Device=%s\r\n",devicename); //output the received setup parameters
      fputs(message,output);

      tty = open("/dev/tty", O_RDWR | O_NOCTTY | O_NONBLOCK); //set the user console port up
      tcgetattr(tty,&oldkey); // save current port settings   
	  //so commands are interpreted right for this program
      // set new port settings for non-canonical input processing  
	  //must be NOCTTY
      newkey.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
      newkey.c_iflag = IGNPAR;
      newkey.c_oflag = 0;
      newkey.c_lflag = 0;       //ICANON;
      newkey.c_cc[VMIN]=1;
      newkey.c_cc[VTIME]=0;
      tcflush(tty, TCIFLUSH);
      tcsetattr(tty,TCSANOW,&newkey);


      //open the device(com port) to be non-blocking (read will return immediately)
      fd = open(devicename, O_RDWR | O_NOCTTY | O_NONBLOCK);
	  fd_glob = fd;
      if (fd < 0)
      {
         perror(devicename);
         exit(-1);
      }

      //install the serial handler before making the device asynchronous
      saio.sa_handler = signal_handler_IO;
      sigemptyset(&saio.sa_mask);   //saio.sa_mask = 0;
      saio.sa_flags = 0;
      saio.sa_restorer = NULL;
      sigaction(SIGIO,&saio,NULL);

      // allow the process to receive SIGIO
      fcntl(fd, F_SETOWN, getpid());
      // Make the file descriptor asynchronous (the manual page says only
      // O_APPEND and O_NONBLOCK, will work with F_SETFL...)
      fcntl(fd, F_SETFL, FASYNC);


	  memset(&oldtio, 0, sizeof(struct termios));
	  if((tcgetattr(fd,&oldtio))<0){
		  printf("error: cannot read old settings"); // save current port settings 
	  }
	  if(cfsetospeed(&newtio, B38400) < 0 || cfsetispeed(&newtio, B38400) < 0 || tcsetattr(fd,TCSAFLUSH,&newtio) < 0){
		  printf("error: cannot set baud rates");
	  }

      //tcgetattr(fd,&oldtio); // save current port settings 
	memset(&newtio, 0, sizeof(struct termios));
	  //bzero(&newtio, sizeof(newtio)); 
	if ((tcgetattr(fd,&newtio)) < 0){
		printf("error: cannot read new attribs");
	}

      // set new port settings for canonical input processing 
      //newtio.c_cflag |= BAUD | CRTSCTS | DATABITS | STOPBITS | PARITYON | PARITY | CLOCAL | CREAD;
//	  newtio.c_cflag |= CRTSCTS | DATABITS | STOPBITS | PARITYON | PARITY | CLOCAL | CREAD;
	  //newtio.c_ispeed = BAUD;
	  //newtio.c_ospeed = BAUD;
//      newtio.c_iflag = IGNPAR;
//      newtio.c_oflag = 0;
//      newtio.c_lflag = 0;       //ICANON;
//      newtio.c_cc[VMIN]=1;
//      newtio.c_cc[VTIME]=0;
//		cfsetispeed(&newtio, B9600);
//		cfsetispeed(&newtio, B9600);
      //tcflush(fd, TCIFLUSH);
//		tcdrain(fd);
//      tcsetattr(fd,TCSANOW,&newtio);

	newtio.c_iflag &= ~(BRKINT | ICRNL | IGNCR | INLCR | INPCK | ISTRIP | IXON | IXOFF | PARMRK);
	newtio.c_iflag |= IGNBRK | IGNPAR;
	newtio.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL | ICANON | IEXTEN | ISIG);
	newtio.c_oflag &= ~(OPOST);
	newtio.c_cflag &= ~(CRTSCTS | CSIZE | HUPCL | PARENB);
	newtio.c_cflag |= (CLOCAL | CS8 | CREAD);
	
	newtio.c_cc[VMIN] = 1;
	newtio.c_cc[VTIME] = 0;
	cfmakeraw(&newtio);
	if((tcsetattr(fd, TCSAFLUSH, &newtio)) < 0){
		printf("error: cannot set new attribs");
	}
	


 tcflush(fd, TCIOFLUSH);
 fflush(NULL);



      // loop while waiting for input. normally we would do something useful here
      while (STOP==FALSE)
      {
         status = fread(&Key,1,1,input);
         if (status==1)  //if a key was hit
         {
				
				

            switch (Key)
            { /* branch to appropiate key handler */
               case 0x1b: /* Esc */
                  STOP=TRUE;
                  break;
			   case 0x61:		// letter"a"
				   addres = 0x70;
				   message[0]= 0xe5;
				   message[1]= 0x00;
				   lenght = 0x2;
				   rtr = 0x00;
				   prio = 0xfb;
				   pakket(prio, rtr, lenght, addres, message);
				   break;
			   case 0x71:		// letter"a"
				   addres = 0x71;
				   message[0]= 0xe5;
				   message[1]= 0x00;
				   lenght = 0x2;
				   rtr = 0x00;
				   prio = 0xfb;
				   pakket(prio, rtr, lenght, addres, message);
				   break;
			   case 0x7A:		// letter"z"
				   //printf("off\r\n");
				   addres = 0x04;
				   message[0]= 0xf5;
				   message[1]= 0x01;
				   lenght = 0x2;
				   rtr = 0x00;
				   prio = 0xfb;
				   pakket(prio, rtr, lenght, addres, message);
				   break;
			   case 0x65:		// letter"e"
				   //printf("on\r\n");
				   addres = 0x04;
				   message[0]= 0xf6;
				   message[1]= 0x01;
				   lenght = 0x2;
				   rtr = 0x00;
				   prio = 0xfb;
				   pakket(prio, rtr, lenght, addres, message);
				   break;
			   case 0x77:		// letter"w"
				   addres = 0x70;
				   message[0]= 0x01;
				   message[1]= 0x01;
				   lenght = 0x0;
				   rtr = 0x40;
				   prio = 0xfb;
				   pakket(prio, rtr, lenght, addres, message);
					break;
               default:			// all others
                  fputc((int) Key,output);
					//sprintf(message,"%x ",Key);  //debug
					//fputs(message,output);
                    //write(fd,&Key,1);          //write 1 byte to the port
                  break;
            }  //end of switch key
         }  //end if a key was hit
		

         // after receiving SIGIO, wait_flag = FALSE, input is available and can be read
         if (wait_flag==FALSE)  //if input is available
         {
            res = read(fd,buf,255);
            if (res>0)
            {
				if (check_valid(buf,res) == TRUE)
				{
					//printf("Valid string: ");
					if (buf[4]==0xe6)
					{
						disp_temp(buf,res);
					}
					else
					{
						disp_data(buf,res);
					}
				}  // end of valid
            }  //end if res>0
            wait_flag = TRUE;      /* wait for new input */
         }  //end if wait flag == FALSE

      }  //while stop==FALSE

      // restore old port settings
      tcsetattr(fd,TCSANOW,&oldtio);
      tcsetattr(tty,TCSANOW,&oldkey);
      close(tty);
      close(fd);        //close the com port

   fclose(input);
   fclose(output);
}  //end of main

unsigned char checksum(unsigned char*lpData, int nSize)
{
unsigned char c = 0;
int i = 0;

for(; i<(nSize-2); ++i)
	c += lpData[i];
return (-c);
}

int check_valid(unsigned char*lpData, int nSize)
{
int check = FALSE;

	if ((lpData[0]==0xF) && (lpData[nSize-1]==0x4))
	{				
		if (checksum(lpData,nSize) == lpData[nSize-2])
		{
			check = TRUE;
		}
	}

	return (check);

}
disp_data(unsigned char*lpData, int nSize)
{
	int i;
	char message[8];
	
	printf("add : %X | ",lpData[2]);

	if (lpData[1] == 0xf8)
	{
		printf("prio : high | ");
	}
	if (lpData[1] == 0xfb)
	{
		printf("prio : low  | ");
	}
	if ((lpData[3]&0xf0)==0x0)
	{
		printf("rtr : off | ");
	}
	if ((lpData[3]&0xf0)==0x40)
	{
		printf("rtr : on  | ");
	}
		
	printf("data : ");
	for (i=4; i<(nSize-2); i++)  //for all chars in string
		{
			sprintf(message,"%X",lpData[i]);
			printf("%s ",message);
		}  //end of for all chars in string
		printf("\n\r");
}

disp_temp(unsigned char*lpData, int nSize)
{
	int i;
	short result;
	float endres;

	result = lpData[5] << 8;
	result |= lpData[6];
	result = (result / 0x20);
	endres = (float)result * 0.0625;
	printf("%.2f\r\n", endres);

}


int pakket(unsigned char prio, unsigned char rtr, unsigned char lenght, unsigned char addres, unsigned char*lpData)
{
	int i;
	unsigned char dest[30];
	dest[0]=0xf;
	dest[1]=prio;
	dest[2]=addres;
	dest[3]=(0xf0 & rtr) | (0xf & lenght);
	for (i=0; i<lenght; i++)
	{
		dest[4+i]=lpData[i];
	}
	dest[lenght+4]=checksum(dest,(lenght + 6));
	dest[lenght+5]=0x4;
	disp_data(dest,(lenght + 6));
	write(fd_glob,dest,(lenght + 6));
	fflush(NULL);
	//return dest;
}
/***************************************************************************
* signal handler. sets wait_flag to FALSE, to indicate above loop that     *
* characters have been received.                                           *
***************************************************************************/

void signal_handler_IO (int status)
{
//printf("received SIGIO signal.\n\r");
   wait_flag = FALSE;
}

#include <stdio.h>   /* Standard input/output definitions */
 #include <string.h>  /* String function definitions */
 #include <unistd.h>  /* UNIX standard function definitions */
 #include <fcntl.h>   /* File control definitions */
 #include <errno.h>   /* Error number definitions */
 #include <termios.h> /* POSIX terminal control definitions */


 int open_port(void)
 {
   int fd;                                   /* File descriptor for the port */

   fd = open("/dev/ttyACM0", O_RDWR | O_NOCTTY | O_NDELAY);

   if (fd == -1)
   {                                              /* Could not open the port */
     fprintf(stderr, "open_port: Unable to open /dev/ttyACM0 - %s\n",
             strerror(errno));
   }

   return (fd);
 }

main()
{
 int mainfd=0;                                            /* File descriptor */
 unsigned char chout;
 struct termios options;
   
 mainfd = open_port();

 fcntl(mainfd, F_SETFL, FNDELAY);                  /* Configure port reading */

 memset(&options, 0, sizeof(struct termios));	/* clear all settings */

 cfsetispeed(&options, B38400);                 /* Set the baud rates to 38400 */
 cfsetospeed(&options, B38400);
    
                                  
 options.c_cflag |= (CLOCAL | CREAD);	 /* Enable the receiver and set local mode */
 options.c_cflag |=  CS8;                              /* Select 8 data bits */
 options.c_cflag |= CRTSCTS;               /* Enable hardware flow control */  
      
                                        /* Set the new options for the port */
 tcsetattr(mainfd, TCSANOW, &options);
                         
 while (1)
 {
   read(mainfd, &chout, sizeof(chout));          /* Read character */
   
   if (chout != 0)
      printf("Got %x.\n", chout);

   chout=0;

 }
                                                    /* Close the serial port */
  close(mainfd);
 }