/**
* ===================================================================================================

 *	  @mainpage Interface de controlo da Unidade Geral de Interface (UGI)
 *      @brief  Este programa permite fazer o controlo e a supervisão dos sensores para bin piking a partir unidade geral de interface
O programa principal biforca-se em dois, ficando a correr em simultaneo o pai e o filho, dois programas distintos.
 O filho é o programa responsável por controlar o fluxo de informação, recebendo e enviando as 
 mensagens pela porta série para o PIC da UGI. 
 O protocolo de comunicação consiste em dois bytes distintos. O primeiro é o que identifica 
 qual é a origem e o destino da informação e o segundo é o que transporta o estado dos dispositivos.
 
 No programa principal são também criadas duas memórias partilhadas: a de envio e a de recepção. 
 O filho lê um byte de cada vez e analiza se este é o primeiro, através do 
 bit mais significativo. O zero identifica o primeiro byte e o um o segundo. Se for o primeiro então coloca a variável "rc_type"
 com o nome do tipo, por exemplo: "ESTADO", "MOTORES". Estas variáveis são do tipo enum e estão definidas no header.h. 
 
 Depois de ler o primeiro byte, o programa está pronto para receber o segundo pois a variavel "rc_type" já está definida. No entanto 
 tem de se verificar se é mesmo o segundo byte, e isso é feito verificando se o bit 7 está a um.
 Se tiverem sido recebidos os dois bytes de identificação e informação de uma variável, então a informação é escrita na 
 memória partilhada de recepção e enviado um sinal para o pai, para este saber que já pode ler da sharememory.As sharememories
 são estruturas constituidas por três campos, em que o primeiro é do tipo enum, e o segundo e o terceiro do tipo 
 inteiro.O primeiro, do tipo enum identifica de que tipo é o sinal: Estado, Motores, Sensores, Garra; o segundo, identifica 
 o numero de cada veriável, para o caso de haver mais de um dispositivo, por exemplo vários sensores de distância.
 
 O pai por sua vez que recebeu o sinal do filho vai ver o que chegou à memoria partilhada, e dependendo do que chegou
 vai actualizar na interface gráfica o estado das vairiáveis.
 
 Da  mesma forma o utilizador ao fazer uma alteração na interface, o pai vai receber um sinal e vai escrever na sharememory de envio.
 Como o filho está a funcionar ciclicamente, está a mandar a informação também continuamente para o PIC. 
 
 A interface contém uma parte de monitorização, uma parte de controlo e uma parte para identificar o estado da ligação. 
 Foram feitos também alguns melhoramentos extra na interface, para facilitar a sua utilização tais como: é possível ver 
 constantemente o estado da ligação RS232, o utilizador pode escolher a porta série a utilizar.
 
 *     @author  Luis Rodrigues, 36386, luis.rodrig@ua.pt
 *
 *   @internal
 *     Created  28-Oct-2009
 *    Revision  ---
 *    Compiler  gcc/g++
 *     Company  University of Aveiro
 *   Copyright  Copyright (c) 2009, Luis Rodrigues
 *
 * ===================================================================================================
 * 
 */
#ifndef MAIN_C
#define MAIN_C

#include "header.h"


int main(int argc, char *argv[])
{			
	/*Criação do primeiro filho*/
	int pid = fork();		

	if(pid == -1)
	{
		printf("Could not fork(). Exiting\n");
		return -1;
	}

	if(pid == 0)  /* The child */
	{
// 	    int pid_RS232 = getpid();
// 	    printf("Pid_RS232comm: %d \n",pid_RS232);

	    printf("I am the RS232_comunic \n");
	    RS232Comunication();
	    printf("CHILD ended\n");
	}

	else  /* The parent */
	{
	    /*Criação do segundo filho*/
	    int pid2 = fork();	    	  						    
	    if(pid2 == -1)
	    {
		printf("Could not fork(). Exiting\n");
		return -1;
	    }

	    if(pid2 == 0)  /* The child */
	    {
// 		int pid_RobComm = getpid();
// 		printf("Pid_RobComm: %d \n",pid_RobComm);

		printf("I am the Script Robot\n");
		RobotComunication();
		printf("Script ended\n");  		
	    }
	    else
	    {
// 		int pid_Interface = getpid();
// 		printf("pid_Interface: %d \n",pid_Interface);

		printf("I am Parent\n");
		ProgInterface(argc, argv);
		printf("PARENT ended\n");               
	    }
	}	

	return 0;
}

#endif