#include

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define

<stdlib.h>
<string.h>
<stdio.h>
<sys/mman.h>
<fcntl.h>
<sys/types.h>
<unistd.h>
<math.h>
<time.h>
<signal.h>
<sys/siginfo.h>
NOMBRE_MEM "/fich.mem"
DEMO "-demo"
BIT_COMIENZO '0'
PARIDAD_IMPAR 1
PARIDAD_PAR 3
PARIDAD_INHABIT 2
TAM_BYTE 8
MIN_BITS_DATOS 5
DIVISOR_BINARIO 2
PARADA_INHABIT 0
PARADA_UNO 1
PARADA_UNOCONCINCO 2
PARADA_DOS 3
FALSE 0
TRUE 1

//VARIABLES GLOBALES
int num_bytes_trans = 0;
int num_bits_datos = -1;
int num_bits_parada = -1;
int num_paridad = 0;
int num_frec = 0;
int cont_padre = 0;
int cont_hijo = 0;
int xor_bytes = 0x00;
int checksum = 0x00;
int long_palabra;
typedef struct estructura {
int bit_comienzo;
char bits_datos[13];
} mensaje;
void inicio()
{
printf("|________________________________________________________
______________________________|\n");
printf("||| *****************************************************
****************************|||\n");
printf("||| *****************************************************
****************************|||\n");
printf("||| *****************************************************
****************************|||\n");
printf("||| *****************************************************
****************************|||\n");
printf("||| ******_______________________________________________
_______________________*****|||\n");

printf("||| ******|
SIMULADOR DE UNA TRANSMISION DE DATOS SERI
|*****|||\n");
printf("||| ******|______________________________________________
______________________|*****|||\n");
printf("||| *****************************************************
****************************|||\n");
printf("||| *****************************************************
****************************|||\n");
printf("||| *****************************************************
****************************|||\n");
printf("||| *****************************************************
****************************|||\n");
printf("|________________________________________________________
______________________________|\n");
printf("\n");
printf("\n");
E ASINCRONA

}
void a_binario(int num, char * resultado)
{
int cociente, binario, i;
char cadena[9], strbin;
for(i=0;i<8;i++)
{
cadena[i]='0';
}
cadena[8]= '\0';
cociente = (num / DIVISOR_BINARIO);
binario = (num % DIVISOR_BINARIO);
i=8;
while(1){
if(binario ==1){
strbin = '1';
}else{
strbin = '0';
}
i=i-1;
cadena[i]=strbin;
cociente = (num / DIVISOR_BINARIO);
binario = (num % DIVISOR_BINARIO);
if(i==1){
cadena[i-1]=strbin;
break;
}
}
strcpy((char *) resultado, cadena);
}
int binario_a_decimal(char * num_binario)
{
char binario[8] = "00000000";
int decimal = 0;
int a;
int b=-1;
double res;

for(a=7; a>=0; a--)

{
b++;
switch(num_binario[b]){
case '0': binario[a] = 0;
break;
case '1': binario [a] = 1;
break;
}
decimal = binario[a] * pow(2,a) + decimal;
}
return decimal;
}
void manejadorP(int s)
{
mensaje * mens;
int memcomp;
int i, byte;
int paridad_byte = 0;
char palabra_byte_dato[9];
char byte_para_xor[9] = "000000000";
int ind_byte_enviado = 0;
struct timespec espera;
int bit_paridad_enviado = FALSE;
memcomp = shm_open(NOMBRE_MEM, O_RDWR, 0x1b6); //ABRO MEM COMPARTIDA
mens = (mensaje *) mmap(0, sizeof(mensaje), PROT_READ|PROT_WRITE,MAP_SHAR
ED, memcomp, 0);
if(mens -> bit_comienzo == 1)
{
cont_padre++;
printf("INICIAMOS LA TRANSMISION\n");
if(num_bits_datos == 0){
ind_byte_enviado
}else if (num_bits_datos
ind_byte_enviado
}else if (num_bits_datos
ind_byte_enviado
}else if (num_bits_datos
ind_byte_enviado
}

= 2;
== 1) {
=1;
==2){
= 0;
==3){
= -1;

srand(time(NULL));
byte = rand() % 0xAA;
a_binario(byte, &palabra_byte_dato[0]);
for (i=0; i<long_palabra; i++)
{
if(i==0){
mens -> bits_datos[i] = BIT_COMIENZO;
} else if (i<MIN_BITS_DATOS+num_bits_datos+1){
byte_para_xor[ind_byte_enviado+i] = palabra_byte_
dato[ind_byte_enviado +i];
mens ->bits_datos[i] = palabra_byte_dato[ind_byte

_enviado + i];
if(mens -> bits_datos[i] == '1'){
paridad_byte = paridad_byte ^ 1;
}
} else if (num_paridad != PARIDAD_INHABIT && bit_paridad_
enviado == FALSE){
if((paridad_byte == 1 && num_paridad == PARIDAD_I
MPAR) ||(paridad_byte == 0 && num_paridad == PARIDAD_PAR)){
mens -> bits_datos[i] = '1';
}else{
mens -> bits_datos[i] = '0';
}
bit_paridad_enviado = TRUE;
} else if(num_bits_parada != PARADA_INHABIT){
mens -> bits_datos[i] = '1';
}
if(num_bits_parada == PARADA_UNOCONCINCO && (i == long_pa
labra -1)){
printf("Bit %d enviado: %c (Medio bit de parada)\
n",i, mens ->bits_datos[i]);
espera.tv_sec = 0;
espera.tv_nsec = 500000000;
nanosleep(&espera,NULL);
}else{
printf("Bit %d enviado: %c\n", i, mens -> bits_da
tos[i]);
espera.tv_sec = 1;
espera.tv_nsec = 0;
nanosleep(&espera,NULL);
}
}
mens -> bits_datos[long_palabra] = '\0';
byte_para_xor[9] = '\0';
xor_bytes = xor_bytes ^binario_a_decimal(&byte_para_xor[0]);
mens -> bit_comienzo = 0;
printf("TERMINAMOS LA TRANSMISION\n");
}
close(memcomp);
}
void manejadorH(int s)
{
int byte;
int i;
mensaje * mens;
int memcomp;
memcomp = shm_open(NOMBRE_MEM, O_RDWR, 0x1b6);
mens = (mensaje *) mmap(0, sizeof(mensaje), PROT_READ | PROT_WRITE,MAP_SH
ARED, memcomp, 0);

if(mens -> bit_comienzo == 0){

char byte_recibido[9] = "000000000";
int ind_byte_recibido, num_recibido;
int paridad_byte = 0;
int bit_paridad_recibido = FALSE;
struct timespec espera;
printf("INICIAMOS LA RECEPCION\n");
cont_hijo++;
if(num_bits_datos == 0){
ind_byte_recibido = 2;
}else if (num_bits_datos == 1) {
ind_byte_recibido =1;
}else if (num_bits_datos ==2){
ind_byte_recibido = 0;
}else if (num_bits_datos ==3){
ind_byte_recibido = -1;
}
for(i=0; i<long_palabra; i++)
{
if(i==0 && mens -> bits_datos[i] != '0'){
printf("Error en el bit de comienzo de los datos
a recibir\n");
}else if( i > 0 && i < MIN_BITS_DATOS + num_bits_datos +
1){
byte_recibido[ind_byte_recibido + i ] = mens -> b
its_datos[i];
if(mens -> bits_datos[i] == '1'){
paridad_byte = paridad_byte ^ 1;
}
}else if(i==MIN_BITS_DATOS+num_bits_datos+1 && num_parida
d !=PARIDAD_INHABIT && bit_paridad_recibido == FALSE){
if(((paridad_byte == 1 && num_paridad == PARIDAD_
IMPAR) ||(paridad_byte == 0 && num_paridad == PARIDAD_PAR)) && mens ->bits_datos
[i] != '1'){
printf("Error en la paridad del dato rec
ibido\n");
} else if (((paridad_byte == 0 && num_paridad ==
PARIDAD_IMPAR) ||(paridad_byte == 1 && num_paridad == PARIDAD_PAR)) && mens ->bi
ts_datos[i] != '0'){
printf("Error en la paridad del dato rec
ibido\n");
}
bit_paridad_recibido = TRUE;
}
if(num_bits_parada == PARADA_UNOCONCINCO && (i == long_pa
labra -1)){
printf("Bit %d recibido: %c (Medio bit de parada)
\n", i, mens ->bits_datos[i]);
espera.tv_sec = 0;
espera.tv_nsec = 500000000;
nanosleep(&espera, NULL);
}else{
printf("Bit %d recibido: %c\n",i,mens -> bits_dat
os[i]);
espera.tv_sec = 1;

espera.tv_nsec = 0;
nanosleep(&espera, NULL);
}
}
byte_recibido[8] = '\0';
num_recibido = binario_a_decimal(&byte_recibido[0]);
checksum = checksum ^num_recibido;
mens -> bit_comienzo = 1;
printf("TERMINAMOS LA RECEPCION\n");
}
close(memcomp);
}
void inicializar_memoria()
{
mensaje * mens;
int memcomp;
memcomp = shm_open(NOMBRE_MEM, O_CREAT | O_RDWR, 0x1b6);
ftruncate(memcomp, sizeof(mensaje));
mens = (mensaje *) mmap(0, sizeof(mensaje), PROT_READ | PROT_WRITE,MAP_SH
ARED, memcomp, 0);
mens -> bit_comienzo = 1;
close(memcomp);
}
int main(int argc, char * argv[])
{
pid_t hijo;
inicio();
if(argc == 1)
{
while((num_bits_parada <0) || (num_bits_parada > 3))
{
printf("Introduzca numero de bits de parada: \n");
printf("0 Inhabilitado\n");
printf("1. 1 bit\n");
printf("2. 1.5 bits\n");
printf("3. 2 bits\n");
scanf("%d", &num_bits_parada);
}
while((num_paridad < 1) || (num_paridad >3))
{
printf("Introduzca tipo de paridad:\n");
printf("1. Paridad Impar\n");
printf("2. Sin paridad\n");
printf("3. Paridad Par\n");
scanf("%d", &num_paridad);
}
while((num_bits_datos <0) || (num_bits_datos > 3))
{
printf("Introduzca numero de bits de datos:\n");
printf("0. 5 bits\n");
printf("1. 6 bits\n");
printf("2. 7 bits\n");

printf("3. 8 bits\n");
scanf("%d", &num_bits_datos);
}
printf("Introduzca la frecuencia de transmision/recepcion:\n");
scanf("%d", &num_frec);
while(num_bytes_trans < 1)
{
printf("Introduzca el numero de bytes a transmitir:\n");
scanf("%d", &num_bytes_trans);
}
} else if (argc == 2){
if(strcmp(argv[argc-1], DEMO) == 0){
printf("Funcionando en modo demostracion.\n");
num_bytes_trans = 2;
num_bits_parada = 1;
num_paridad = 1;
num_bits_datos = 0;
num_frec = 1;
} else {
printf("Error por argumento incorrecto\n");
return -1;
}
}else{
printf("Numero incorrecto de argumentos\n");
return -1;
}
printf("\n");
inicializar_memoria();
long_palabra = 1 +MIN_BITS_DATOS + num_bits_datos;
if(num_paridad != PARIDAD_INHABIT){
long_palabra++;
}
if(num_bits_parada == PARADA_UNO){
long_palabra++;
}else if (num_bits_parada == PARADA_UNOCONCINCO || num_bits_parada ==PARA
DA_DOS){
long_palabra = long_palabra +2;
}
hijo = fork();
if(hijo == -1){
printf("ERROR! No pudo crearse el hijo.\n");
} else if (hijo == 0){
// HIJO
struct sigaction accion;
struct sigevent evp;
timer_t temp_id;
struct itimerspec valor;
char checksum_xor[9];
accion.sa_handler = manejadorH;
sigemptyset(&accion.sa_mask);
accion.sa_flags = 0;
sigaction(SIGUSR2, &accion, 0);
evp.sigev_notify= SIGEV_SIGNAL;

evp.sigev_signo = SIGUSR2;
timer_create(CLOCK_REALTIME, &evp, &temp_id);
valor.it_value.tv_sec = 1;
valor.it_value.tv_nsec = 50000;
valor.it_interval.tv_sec = 2;
valor.it_interval.tv_nsec = 0;
timer_settime(temp_id, 0, &valor, 0);
while(cont_hijo < num_bytes_trans){
}
timer_delete(temp_id);
a_binario(checksum, &checksum_xor[0]);
printf("XOR checksum: %s\n", checksum_xor);
}else{

return 0;
//PADRE
struct sigaction accion;
struct sigevent evp;
timer_t temp_id;
struct itimerspec valor;
char palabra_byte_xor[9];
accion.sa_handler = manejadorP;
sigemptyset(&accion.sa_mask);
accion.sa_flags = 0;
sigaction(SIGUSR1, &accion, 0);
evp.sigev_notify= SIGEV_SIGNAL;
evp.sigev_signo = SIGUSR1;
timer_create(CLOCK_REALTIME, &evp, &temp_id);
valor.it_value.tv_sec = 1;
valor.it_value.tv_nsec = 0;
valor.it_interval.tv_sec = 2;
valor.it_interval.tv_nsec = 0;
timer_settime(temp_id, 0, &valor, 0);
while(cont_padre < num_bytes_trans){
}
timer_delete(temp_id);
a_binario(xor_bytes, &palabra_byte_xor[0]);
waitpid(hijo, NULL, 0);
printf("XOR de los datos: %s\n", palabra_byte_xor);

}
return 0;
}