#INCLUDE <16F628A.H>
#FUSES LP,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
#USE DELAY (INTERNAL=4MHz)
#DEFINE trans1 PORTB,0
#DEFINE trans2 PORTB,1
#DEFINE trans3 PORTB,2
#DEFINE trans4 PORTB,3
#BYTE PORTA = 5
#BYTE PORTB = 6

int8 lecturaPuertoA;
int16 i,NoOpSeccion1int,NoOpSeccion2int,NoOpSeccion3int,NoOpSeccion4int,OpSeccion1int,OpSeccion2int,OpSeccion3int,OpSeccion4int;
float32 Frecuencia,Tiempo,BaseTotalPorSeccion,NoOpSeccion1,NoOpSeccion2,NoOpSeccion3,NoOpSeccion4,OpSeccion1,OpSeccion2,OpSeccion3,OpSeccion4;
//float32 NoOpSeccion1Us,NoOpSeccion2Us,NoOpSeccion3Us,NoOpSeccion4Us,OpSeccion1Us,OpSeccion2Us,OpSeccion3Us,OpSeccion4Us;

VOID apagadoVariador();
VOID escribirPulsoPositivo(int16 NoOpSeccion, int16 OpSeccion);
VOID escribirPulsoNegativo(int16 NoOpSeccion, int16 OpSeccion);

void main()
{
   SET_TRIS_A (1);
   SET_TRIS_B (0);
   while(true){
         i=0;
         lecturaPuertoA= INPUT_A();
//!         
         switch(lecturaPuertoA){
            case(0b00100000):
               apagadoVariador();
               break;
            case(0b00100001):
               Frecuencia = 8.5714;
               break;
            case(0b00100010):
               Frecuencia = 17.1414;
               break;
            case(0b00100011):
               Frecuencia = 25.7114;
               break;
            case(0b00100100):
               Frecuencia = 34.2814;
               break;
            case(0b00100101):
               Frecuencia = 42.85;
               break;
            case(0b00100110):
               Frecuencia = 51.42;
               break;
            case(0b00100111):
               Frecuencia = 60;
               break;
            default:
               apagadoVariador();
               break;
         }


//!         //Todas las unidades hasta este punto estan dadas en segundos
//!         Tiempo = 1/Frecuencia;
//!         BaseTotalPorSeccion=Tiempo/14;
//!         
//!         OpSeccion1=(BaseTotalPorSeccion*0.221896);
//!         OpSeccion2=(BaseTotalPorSeccion*0.613570);
//!         OpSeccion3=(BaseTotalPorSeccion*0.889739);
//!         OpSeccion4=(BaseTotalPorSeccion*0.987535);
//!         
//!         NoOpSeccion1=((BaseTotalPorSeccion-OpSeccion1)/2);
//!         NoOpSeccion2=((BaseTotalPorSeccion-OpSeccion2)/2);
//!         NoOpSeccion3=((BaseTotalPorSeccion-OpSeccion3)/2);
//!         NoOpSeccion4=((BaseTotalPorSeccion-OpSeccion4)/2);
//!         //Todas las unidades hasta este punto estan dadas en segundos
//!         
//!         
//!         //Multiplicando por 1,000,000 para obtener el valor en microsegundos
//!         OpSeccion1=OpSeccion1*1000000;
//!         OpSeccion2=OpSeccion2*1000000;
//!         OpSeccion3=OpSeccion3*1000000;
//!         OpSeccion4=OpSeccion4*1000000;
//!         
//!         NoOpSeccion1=NoOpSeccion1*1000000;
//!         NoOpSeccion2=NoOpSeccion2*1000000;
//!         NoOpSeccion3=NoOpSeccion3*1000000;
//!         NoOpSeccion4=NoOpSeccion4*1000000;
//!         //Multiplicando por 1,000,000 para obtener el valor en microsegundos
//!         
//!         //Convirtiendo el tipo de dato de float a int16
//!         OpSeccion1int=(int)OpSeccion1;
//!         OpSeccion2int=(int)OpSeccion2;
//!         OpSeccion3int=(int)OpSeccion3;
//!         OpSeccion4int=(int)OpSeccion4;
//!         
//!         NoOpSeccion1int=(int)NoOpSeccion1;
//!         NoOpSeccion2int=(int)NoOpSeccion2;
//!         NoOpSeccion3int=(int)NoOpSeccion3;
//!         NoOpSeccion4int=(int)NoOpSeccion4;
//!         //Convirtiendo el tipo de dato de float a int16


         //Todas las unidades hasta este punto estan dadas en segundos
         //Frecuencia=60;
         Tiempo = 1/Frecuencia;
         BaseTotalPorSeccion=Tiempo/14;
         
//!         Tiempo = 1/60;
//!         BaseTotalPorSeccion=0.001190476;
         
         OpSeccion1=(BaseTotalPorSeccion)*(0.221896);
         OpSeccion2=(BaseTotalPorSeccion)*(0.613570);
         OpSeccion3=(BaseTotalPorSeccion)*(0.889739);
         OpSeccion4=(BaseTotalPorSeccion)*(0.987535);
         
         NoOpSeccion1=((BaseTotalPorSeccion-OpSeccion1)/2);
         NoOpSeccion2=((BaseTotalPorSeccion-OpSeccion2)/2);
         NoOpSeccion3=((BaseTotalPorSeccion-OpSeccion3)/2);
         NoOpSeccion4=((BaseTotalPorSeccion-OpSeccion4)/2);
         
         
//!                  
//!         OpSeccion1=0.00026414;
//!         OpSeccion2=0.000730393;
//!         OpSeccion3=0.0010591;
//!         OpSeccion4=0.001175561;
//!         
//!         NoOpSeccion1=0.000463125;
//!         NoOpSeccion2=0.00023;
//!         NoOpSeccion3=0.00006565;
//!         NoOpSeccion4=0.00000745;
         //Todas las unidades hasta este punto estan dadas en segundos
         
         
         
         
         //Multiplicando por 1,000,000 para obtener el valor en microsegundos
//!         OpSeccion1Us=(OpSeccion1)*(1000)*(1000);
//!         OpSeccion2Us=(OpSeccion2)*(1000)*(1000);
//!         OpSeccion3Us=(OpSeccion3)*(1000)*(1000);
//!         OpSeccion4Us=(OpSeccion4)*(1000)*(1000);
//!         
//!         NoOpSeccion1Us=(NoOpSeccion1)*(1000)*(1000);
//!         NoOpSeccion2Us=(NoOpSeccion2)*(1000)*(1000);
//!         NoOpSeccion3Us=(NoOpSeccion3)*(1000)*(1000);
//!         NoOpSeccion4Us=(NoOpSeccion4)*(1000)*(1000);
         
       
            OpSeccion1int=(OpSeccion1)*(1000)*(1000);
            OpSeccion2int=(OpSeccion2)*(1000)*(1000);
            OpSeccion3int=(OpSeccion3)*(1000)*(1000);
            OpSeccion4int=(OpSeccion4)*(1000)*(1000);
            
            NoOpSeccion1int=(NoOpSeccion1)*(1000)*(1000);
            NoOpSeccion2int=(NoOpSeccion2)*(1000)*(1000);
            NoOpSeccion3int=(NoOpSeccion3)*(1000)*(1000);
            NoOpSeccion4int=(NoOpSeccion4)*(1000)*(1000);
         
         
//!         
//!            OpSeccion1Us=264.149;
//!            OpSeccion2Us=730.393;
//!            OpSeccion3Us=1059.1;
//!            OpSeccion4Us=1175.561;
//!            
//!            NoOpSeccion1Us=463.125;
//!            NoOpSeccion2Us=230;
//!            NoOpSeccion3Us=65.65;
//!            NoOpSeccion4Us=7.45;
         //Multiplicando por 1,000,000 para obtener el valor en microsegundos
         
         
         
         
         
         //Convirtiendo el tipo de dato de float a int16
//!         OpSeccion1int=(int)OpSeccion1Us;
//!         OpSeccion2int=(int)OpSeccion2Us;
//!         OpSeccion3int=(int)OpSeccion3Us;
//!         OpSeccion4int=(int)OpSeccion4Us;
//!         
//!         NoOpSeccion1int=(int)NoOpSeccion1Us;
//!         NoOpSeccion2int=(int)NoOpSeccion2Us;
//!         NoOpSeccion3int=(int)NoOpSeccion3Us;
//!         NoOpSeccion4int=(int)NoOpSeccion4Us;
         
         
//!         OpSeccion1int=OpSeccion1Us;
//!         OpSeccion2int=OpSeccion2Us;
//!         OpSeccion3int=OpSeccion3Us;
//!         OpSeccion4int=OpSeccion4Us;
//!         
//!         NoOpSeccion1int=NoOpSeccion1Us;
//!         NoOpSeccion2int=NoOpSeccion2Us;
//!         NoOpSeccion3int=NoOpSeccion3Us;
//!         NoOpSeccion4int=NoOpSeccion4Us;
         
//!         OpSeccion1int=264;
//!         OpSeccion2int=730;
//!         OpSeccion3int=1059;
//!         OpSeccion4int=1175;
//!         
//!         NoOpSeccion1int=463;
//!         NoOpSeccion2int=230;
//!         NoOpSeccion3int=65;
//!         NoOpSeccion4int=7;
         //Convirtiendo el tipo de dato de float a int16


         
         if (Frecuencia>0){
            for(i=0;i<=600;i++){
               /////////----------------Semiciclo positivo--------------////////////////
               
               //Primera seccion
               escribirPulsoPositivo(NoOpSeccion1int,OpSeccion1int);
               //Primera seccion
               
               //Segunda seccion
               escribirPulsoPositivo(NoOpSeccion2int,OpSeccion2int);
               //Segunda seccion
               
               //Tercera seccion
               escribirPulsoPositivo(NoOpSeccion3int,OpSeccion3int);
               //Tercera seccion
               
               //Cuarta seccion
               escribirPulsoPositivo(NoOpSeccion4int,OpSeccion4int);
               //Cuarta seccion
               
               //Quinta seccion
               escribirPulsoPositivo(NoOpSeccion3int,OpSeccion3int);
               //Quinta seccion
               
               //Sexta seccion
               escribirPulsoPositivo(NoOpSeccion2int, OpSeccion2int);
               //Sexta seccion
               
               //Septima seccion
               escribirPulsoPositivo(NoOpSeccion1int,OpSeccion1int);
               //Septima seccion
               /////////----------------Semiciclo positivo--------------////////////////
               
               
               
               /////////----------------Semiciclo negativo--------------////////////////
               
               
               //Primera seccion
               escribirPulsoNegativo(NoOpSeccion1int,OpSeccion1int);
               //Primera seccion
               
               //Segunda seccion
               escribirPulsoNegativo(NoOpSeccion2int,OpSeccion2int);
               //Segunda seccion
               
               //Tercera seccion
               escribirPulsoNegativo(NoOpSeccion3int,OpSeccion3int);
               //Tercera seccion
               
               //Cuarta seccion
               escribirPulsoNegativo(NoOpSeccion4int,OpSeccion4int);
               //Cuarta seccion
               
               //Quinta seccion
               escribirPulsoNegativo(NoOpSeccion3int,OpSeccion3int);
               //Quinta seccion
               
               //Sexta seccion
               escribirPulsoNegativo(NoOpSeccion2int, OpSeccion2int);
               //Sexta seccion
               
               //Septima seccion
               escribirPulsoNegativo(NoOpSeccion1int,OpSeccion1int);
               //Septima seccion
               
               /////////----------------Semiciclo negativo--------------////////////////
            }
         }
   }
}


VOID apagadoVariador(){
   Frecuencia = 0;
   BIT_CLEAR(trans1);
   BIT_CLEAR(trans2);
   BIT_CLEAR(trans3);
   BIT_CLEAR(trans4);
}

VOID escribirPulsoNegativo(int16 NoOpSeccion, int16 OpSeccion){
   DELAY_US(NoOpSeccion);
   BIT_SET(trans2);
   BIT_SET(trans4);
   DELAY_US(OpSeccion);
   BIT_CLEAR(trans2);
   BIT_CLEAR(trans4);
   DELAY_US(NoOpSeccion);
}

VOID escribirPulsoPositivo(int16 NoOpSeccion, int16 OpSeccion){
   DELAY_US(NoOpSeccion);
   BIT_SET(trans1);
   BIT_SET(trans3);
   DELAY_US(OpSeccion);
   BIT_CLEAR(trans1);
   BIT_CLEAR(trans3);
   DELAY_US(NoOpSeccion);
}