Programas hechos en MPLAB

Bueno amigos!!! He estado trabajando en un buen proyecto que a todos les va a interesar, es un controlador para 8 servos. Que contiene un software para controlarlos via serial. Batalle para porde hacer esto mas simple para proigrama del PIC.
El software esta hecho en C#. Gracias a esto ustedes contruiran su propio controlador y asi ya no estaran gastando para comprar uno. Ustedes mismos podran hacer un controlador.

Este es el programa que contiene el microcontrolador PIC.

Código:
////////////////////////////////////////////////////////////////////
//TITULO: CONTROL DE 8 SERVOMOTORES PARA HITEC                  //////
//AUTOR: JORGE ARTURO RODRIGUEZ HERNANDEZ                      //////
//FECHA: 11-12-09                                              //////
//DESCRIPCION: POR MEDIO DEL PROGRAMA CONTROL DE 8 SERVOS.EXE //////
//               CONTROLARAS POR MEDIO DE BARRAS QUE TE INDICARA//////
//               EL GRADO Y EL SERVO A CONTROLAR.               //////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////

#include<16F628A.H>
#fuses HS,NOWDT,NOLVP,MCLR,NOPROTECT

//HS: CRISTAL DE HIGH SPEED 20MHZ
//NOWDT: NO SE UTILIZA EL PERRO GUARDIAN
//NOLVP: SE DESACTIVA ESTA OPCION DE PROGRAMACION
//MCLR:ACTIVAMOS EL MASTER CLEAN
//NOPROTECT: NO SE PROTEGE EL CODIGO()

#use delay(clock=20000000)            //CRISTAL DE 20MHZ
#use rs232(uart1,baud=2400)            //PIN_B1->RX,PIN_B2->TX
#use fast_io(A)                     //RAPIDA INTERVENCION DEL PUERTO A
#use fast_io(B)                        // ''          ''         PUERTO B
#priority timer1,rda                //Es mas primordial que se atienda la interrupcion
                                    //en el timer1
//CONSTANTES DE ENCENDIDO

int ON='A';

//VARIABLES A CONTROLAR

unsigned long tick;            //E
unsigned int SERVO=0;        //ES EL NUMERO DEL SERVO A CONTRLAR MAXIMO CONTAR DE 0 A 7
unsigned int PUERTO=5;        //SOLO AQUI PASA DEL 5 A 6
short LAHL=1;                // SOLO AQUI HACES EL SWITCHEO CUANDO ESTA ALTO O BAJO
short FLAG=0;                //ACTUALIZADOR
unsigned long AUX,AUXH,AUXL;//AUXILIARES PARA OPERACIONES
unsigned int NSERVO=0;        //NUMERO DE SERVO SELECCIONADO
unsigned long POSICION=180;        //0 - 180 grados maximo
unsigned int i;

//VARIABLE DE CONTROL DE PULSO DE ALTO Y BAJO PARA LOS 8 SERVOS 
//COLOCADO COMO UN ARREGLO

unsigned long HIGH[]={0,0,0,0,0,0,0,0};
unsigned long LOW[] ={0,0,0,0,0,0,0,0};

void config(void){

        output_a(0x00);
        output_b(0x00);
        set_tris_a(0xA0);
        set_tris_b(0x02);
        output_bit(PIN_B3,1);
        setup_comparator(NC_NC_NC_NC);            //Comparadores APAGADO
        setup_timer_1(T1_INTERNAL|T1_DIV_BY_1); //Tick de 0.0002ms
        set_timer1(tick);
        disable_interrupts(INT_TIMER1);
        disable_interrupts(INT_RDA);
        disable_interrupts(GLOBAL);
}

#INT_TIMER1
void Interrupcion_timer1(void){

        if(LAHL==1){                    //SI ES PARA EL TIEMPO ALTO? ENTRA
            bit_set(*PUERTO,SERVO);        //ESTABLECE EL PIN A PRENDER
            tick=HIGH[SERVO];            //TOMA LOS TICK NECESARIOS PARA TIEMPO EN ALTO
            LAHL=0;                        //LO CAMBIA PARA EL TIEMPO BAJO
        }else if(LAHL==0){                //SI ES PARA EL TIEMPO BAJO? ENTRA
            bit_clear(*PUERTO,SERVO);    //PONE A BAJO EL PIN QUE CORRESPONDE
            SERVO++;                    //INCREMENTA PARA SIGUIENTE SERVO
            if(SERVO>=4){                //HA TERMINADO EN EL PUERTO A?
                if(SERVO>=4 && PUERTO==5){ //CAMBIA AL PUERTO B, Y ENCIENDE EL PIN 4
                    PUERTO=6;
                    SERVO=4;
                }else if(SERVO>=8 && PUERTO==6){ //HA LLEGADO EL LIMITE DEL PUERTO B
                    PUERTO=5;            //CAMBIA EL PUERTO A
                    SERVO=0;            //Y EMPIEZA EL CICLO DESDE EL PIN CERO 
                }
        }
            tick=LOW[SERVO];            //TOMA EL TICK PARA EL TIEMPO BAJO
            LAHL=1;                        //LO CAMBIA PARA EL TIEMPO ALTO
        }    
        set_timer1(tick);                //ESTABLECE EL TIMER PARA MANTENER EL PUSLO ALTO
                                        //O BAJO PARA EL PIN QUE CORRESPONDA
}


#INT_RDA
void Interrupcion_X_recepcion(void){

        disable_interrupts(INT_TIMER1);//DESACTIVA EL TIMER 1
        if(kbhit()){                    //HAY INFORMACION A CAPTAR
            NSERVO=getc();                //1ER BYTE PARA EL NUMERO DEL SERVO
            POSICION=getc();            //2DO BYTE PARA LA POSICION
        }
        FLAG=1;    //ESTE PARAMETRO TE INDICA QUE SE A EFECTUADO UN CAMBIO EN UN DE LOS
                //SERVOMOTORES
        set_timer1(get_timer1());        //CUANDO SE SALIO DE LA RUTINASE QUEDO CON UN
        enable_interrupts(INT_TIMER1);    //CIERTO VALOR EL TIMER 1, ENTONCES LO TOMAMOS 
}                                        //PARA QUE SIGA DONDE SE QUEDO...

void main(void){

        config();
        ON=getc();
        if(ON=='E'){
            printf("----Control de Servomotores----\r\n");
            printf("Version 1.0\r\n");
            printf("Contacto: george.manson.69@gmail.com\r\n");
            printf("Window XP SP3\r\n");
            printf("\r\n");
            printf("Inicializar Servos:\r\n");
            for(i=0;i<=7;i++){
                printf("SERVO %u: ",i);
                POSICION=getc();
                printf("%Lu Grados \r\n",POSICION);
                AUX=(POSICION*34)+4400; //AQUI OBTIENES LOS TICK'S                    
                AUXH=65536-AUX;             //AQUI OBTIENES EL TIEMPO EN ALTO        
                HIGH[i]=AUXH;        //ACTUALIZA EL SERVO SELECCIONADO
                AUX=12500-AUX;            //2.5ms - (TIEMPO TRANSCURRIDO EN ALTO)
                AUXL=65536-AUX;            //AQUI OBTIENES EL TIEMPO BAJO
                LOW[i]=AUXL;        //ACTUALIZAS SERVO SELECCIONADO
            }
            output_bit(PIN_B0,1);
            output_bit(PIN_B3,0);
            enable_interrupts(GLOBAL);
            enable_interrupts(INT_TIMER1);
            enable_interrupts(INT_RDA);
        }

        while(TRUE){
            if(FLAG==1){
                Printf("SERVO %u: %Lu Grados...\r\n",NSERVO,POSICION);
                disable_interrupts(INT_RDA);
                AUX=(POSICION*34)+4400; //AQUI OBTIENES LOS TICK'S                    
                AUXH=65536-AUX;             //AQUI OBTIENES EL TIEMPO EN ALTO        
                HIGH[NSERVO]=AUXH;        //ACTUALIZA EL SERVO SELECCIONADO
                AUX=12500-AUX;            //2.5ms - (TIEMPO TRANSCURRIDO EN ALTO)
                AUXL=65536-AUX;            //AQUI OBTIENES EL TIEMPO BAJO
                LOW[NSERVO]=AUXL;        //ACTUALIZAS SERVO SELECCIONADO
                FLAG=0;
                enable_interrupts(INT_RDA);
            }
        };
}

La explicacion es muy simple, conectamos el cirucito al serial por medio del Max232,
abrimos el archivo de CONTROL DE 8 SERVOS.exe entonces buscamos el COM en donde esta conectado y presionamos CONECTAR, aparacera un menu y luego nos pedira inicializar donde dice el INICIALIZADOR ahi movemos la barra para cada servo que, cuando completemos los 8 servos, los servos se posicionara en lo que se puso en el inicializador, y luego ya podremos controlarlos uno por uno con las barras respectivas.

Yo lo probe fisicamente y funciono correctamanete.

Espero que les guste...y Esperen mas proyectos mas complejos!!! :)
 

Adjuntos

Esta interesante tu post pero tengo una duda a ver si me puedes colaborar as oido del compilador FED C es que necesito realizar control de dipositivos de temperatura y me recomendaron este compilador.
 
si ese es un amigo que lo maneja dice que tiene excelentes prestacion como si estuvieran unidos el proteus , niple el asm y el compilador porque se puede ver todo y simularlo a la vez
 
si ese es un amigo que lo maneja dice que tiene excelentes prestacion como si estuvieran unidos el proteus , niple el asm y el compilador porque se puede ver todo y simularlo a la vez

Ok estare usandolo..para aprenderle...estoy viendo que esta facil prormarlo...solo le falta las librerias...bueno algunas...pero Que es mejor WIZ-C o CCS C? Cual e la primarodial diferencia?
 
Mira he utilizado el mkro c y el ccs compiler pero cuando vi como se realizaban proyectos con el FED C me asombre por el programa cuando un amigo utilizo una pantalla grafica y hay estaba la libreria y el elemento propiamente dicho y en cuestion de minutos la hizo funcionar pero toda la informacion que me sumistro esta en ingles con eso te dijo que es un lenguaje dealto nivel mas aplicado al usuario., pero el entorno de la programacion es en C.

te agregare com amigo para tratar este tema y no darle otro camino a tu hilo
 
Última edición:
soy nuevo en esto,,
me he bajado el compilador pic c compiler con muchos ejemplos..
pero de c solo se que nada se..
me gustaria aprender paso por paso,,si alguien tiene un tuto, que detalle instrucciones y su uso con ejemplos
por favor hagamelo llegar..
Gracias desde ya a todos los amigos del foro..
 
Bueno antes de que termine el año!!!, aqui les traigo un control de 5 servomotores que puden grabar maximo de 2 a 9 posiciones para cada servo.


Como funciona:
1.-Abrimos el programa de CONTROL DE SERVOS V1,1 BETA
2.-Creamos dos puertos virtuales con "virual serial port" y despues conectamos nuestro programita antes de simular en proteus.
3.-Al estar conectado, ya podemos ponerle play en proteus
4.-Nos pedira la inicializacion de los servos, es hara que los servos se establesza en un lugar al iniciar.
5.-Nos pedira despues si queremos controlarlos manualmente, o queremos grabar las posiciones de los servos. Hay dos boton que dicen "REC" O "MANUAL" ahi responderemos. Si queremos manual los servos ESPERARAN la senal para que gire a los grados que queremos.
Si queremos grabar servos:
Al presionar "REC" los servos se posicionaran en el lugar indicado(donde se inicializaron los servos),
Empezamos a mover los servos siempre y cuando no sea la misma posicion, ya que no se grabara, tambien se debe de acalarar que es preferible empezar a grabar de 0 a 4 y luego otra vez de 0 a 4 y asi las veces que allas puesto que grabara en el codigo.
Porque al inciar los servos empezara por decirlo asi por rondas, por ejemplo en la primera ronda de 0 a 4, se graba algo inicia, ahi lo grabado y luego la segunda ronda empieza de 0 a 4 y asi.
Si tiene alguna duda como mucho gusto aqui andamos...!!!
Código:
////////////////////////////////////////////////////////////////////
//TITULO: CONTROL DE 5 SERVOMOTORES CON GRABAMIENTO DE-       //////
//    POSICION PARA HITEC O PARECIDO       //////
//AUTOR: JORGE ARTURO RODRIGUEZ HERNANDEZ       //////
//FECHA: 11-12-09             //////
//DESCRIPCION: POR MEDIO DEL PROGRAMA CONTROL DE 5 SERVOS.EXE //////
//      CONTROLARAS POR MEDIO DE BARRAS QUE TE INDICARA//////
//      EL GRADO Y EL SERVO A CONTROLAR.               //////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
#include<16F886.H>
#fuses HS,NOWDT,NOLVP,MCLR,NOPROTECT
//HS: CRISTAL DE HIGH SPEED 20MHZ
//NOWDT: NO SE UTILIZA EL PERRO GUARDIAN
//NOLVP: SE DESACTIVA ESTA OPCION DE PROGRAMACION
//MCLR:ACTIVAMOS EL MASTER CLEAN
//NOPROTECT: NO SE PROTEGE EL CODIGO()
#use delay(clock=20000000)   //CRISTAL DE 20MHZ
#use rs232(uart1,baud=2400)   //PIN_C7->RX,PIN_C6->TX
#use fast_io(C)      //RAPIDA INTERVENCION DEL PUERTO C
#priority timer1,rda    //Es mas primordial que se atienda la interrupcion
         //en el timer1
//VARIABLES A CONTROLAR
unsigned long tick;   //E
unsigned int SERVO=0;  //ES EL NUMERO DEL SERVO A CONTRLAR MAXIMO CONTAR DE 0 A 4
unsigned int PUERTO=7;  //SOLO PARA EL PUERTO C
unsigned long AUX,AUXH,AUXL;//AUXILIARES PARA OPERACIONES
unsigned int NSERVO=0;  //NUMERO DE SERVO SELECCIONADO
unsigned long POSICION=180; //0 - 180 grados maximo
unsigned int Respuesta;  //RESPUESTA DE LO QUE SE QUIERE HACER G o M
unsigned int x=0;   //INDICA COLUMNAS
unsigned int PULSO;   //TE INDICA EL TIEMPO QUE TIENE QUE ESPERAR PARA CAMBIAR DE POSICION
short SW=0;     //ACTIVA LA REPRODUCCION DE LO QUE SE GRABO
short LAHL=1;    // SOLO AQUI HACES EL SWITCHEO CUANDO ESTA ALTO O BAJO
short FLAG=0;    //ACTUALIZADOR
//VARIABLE DE CONTROL DE PULSO DE ALTO Y BAJO PARA LOS 5 SERVOS 
//COLOCADO COMO UN ARREGLO
unsigned long HIGH[]={0,0,0,0,0};  //ARREGLO PARA GUARDAR LA POSICION EN TIEMPO ALTO
unsigned long LOW[] ={0,0,0,0,0}; //ARREGLO PARA GUARDAR LA POSICION EN TIEMPO BAJO
//MAXIMO DE MEMORIA PARA GRABAR PARA CADA SERVO
unsigned int s[]={0,0,0,0,0};  //ARREGLO PARA GRABAR LAS POSICIONES DE LOS SERVOS
//VARIABLE QUE GUARDA LAS POSICIONES DE LOS SERVOS
unsigned long INH[4]={};   //ARREGLO DE VARIABLES DE INICIALIZADOR
unsigned long INL[4] ={};   //------------------------------------
unsigned long TEMPH[4]={};   //ARREGLO TEMPORAL PARA ALTO
unsigned long TEMPL[4]={};   //--------------------- BAJO
//SI SE DESEA CAMBIAR EL 9 PARA QUE SEA MENOS PASOS A GRABAR 
unsigned long SERVOH[5][4];   //MATRIZ DONDE SE PIENSA GUARDAR TODAS LAS POSICONES DE CADA SERVO ALTO
unsigned long SERVOL[5][4];   //---------------------------------------------------------------- BAJO
//FUNCION DE CONFIGURACION DEL MICROCONTROLADOR
void config(void){
  set_tris_a(0x01);
  set_tris_c(0x80);      //1000 0000
  setup_adc(ADC_OFF);      //CONVERTIDOR ANALOGO-DIGITAL APAGADO
  setup_comparator(NC_NC_NC_NC);   //Comparadores APAGADO
  setup_timer_1(T1_INTERNAL|T1_DIV_BY_1); //Tick de 0.0002ms
  set_timer1(tick);
  disable_interrupts(GLOBAL);
  enable_interrupts(INT_TIMER1);
  enable_interrupts(INT_RDA);
}
//INTERRUPCION EN EL TIMER 1, DEPENDE DE LO QUE SE ALLA CARGADO EN EL TIMER1
#INT_TIMER1
void Interrupcion_timer1(void){
  if(LAHL==1){     //SI ES PARA EL TIEMPO ALTO? ENTRA
   bit_set(*PUERTO,SERVO);  //ESTABLECE EL PIN A PRENDER
   tick=HIGH[SERVO];   //TOMA LOS TICK NECESARIOS PARA TIEMPO EN ALTO
   LAHL=0;      //LO CAMBIA PARA EL TIEMPO BAJO
  }else if(LAHL==0){    //SI ES PARA EL TIEMPO BAJO? ENTRA
   bit_clear(*PUERTO,SERVO); //PONE A BAJO EL PIN QUE CORRESPONDE
   SERVO++;     //INCREMENTA PARA SIGUIENTE SERVO
   if(SERVO>=5){    //HA TERMINADO EN EL PUERTO A?
    SERVO=0;    //EMPIEZA OTRA VEZ
    if(SW==1){    //EMPEZAR EL MOVIMIENTO GUARDADO
     PULSO++;   //INCREMENTA VARIABLE
     if(PULSO==75){  //HA LLEGADO A 75 PULSOS?
      disable_interrupts(GLOBAL);//APAGAMOS TEMPORALEMNTE LAS INTERRUPTIONES
     }
    }
   }
   tick=LOW[SERVO];   //TOMA EL TICK PARA EL TIEMPO BAJO
   LAHL=1;      //LO CAMBIA PARA EL TIEMPO ALTO     
  }
  set_timer1(tick);    //ESTABLECE EL TIMER PARA MANTENER EL PUSLO ALTO
          //O BAJO PARA EL PIN QUE CORRESPONDA
}
//INTERRUPCION DE RECEPCION
#INT_RDA
void Interrupcion_X_recepcion(void){
  disable_interrupts(INT_TIMER1);//DESACTIVA EL TIMER 1
  if(kbhit()){     //HAY INFORMACION A CAPTAR
   NSERVO=getc();    //1ER BYTE PARA EL NUMERO DEL SERVO
   POSICION=getc();   //2DO BYTE PARA LA POSICION
  }
  FLAG=1; //ESTE PARAMETRO TE INDICA QUE SE A EFECTUADO UN CAMBIO EN UN DE LOS
    //SERVOMOTORES
  set_timer1(get_timer1());  //CUANDO SE SALIO DE LA RUTINASE QUEDO CON UN
  enable_interrupts(INT_TIMER1); //CIERTO VALOR EL TIMER 1, ENTONCES LO TOMAMOS 
}          //PARA QUE SIGA DONDE SE QUEDO...
//PONE EN LA POSICION DEL INICIALIZADOR
void PUNTO_DE_INICIO(void){
  for(NSERVO=0;NSERVO<=4;NSERVO++){
   HIGH[NSERVO]=INH[NSERVO]; //AGARRA LOS VALORES ALTOS DE CADA SERVO
   LOW[NSERVO]=INL[NSERVO];  //AGARRA LOS VALORES BAJOS DE CADA SERVO
  }
}
//ACEPTO LO DE MANEJAR SERVOS MANUALMENTE
void MANUAL(void){
  enable_interrupts(GLOBAL);
  while(TRUE){
   if(FLAG==1){
    Printf("SERVO %u: %Lu Grados...\r\n",NSERVO,POSICION);
    disable_interrupts(INT_RDA);
    AUX=(POSICION*34)+4400; //AQUI OBTIENES LOS TICK'S     
    AUXH=65536-AUX;    //AQUI OBTIENES EL TIEMPO EN ALTO  
    HIGH[NSERVO]=AUXH;  //ACTUALIZA EL SERVO SELECCIONADO
    AUX=20000-AUX;   //2.5ms - (TIEMPO TRANSCURRIDO EN ALTO)
    AUXL=65536-AUX;   //AQUI OBTIENES EL TIEMPO BAJO
    LOW[NSERVO]=AUXL;  //ACTUALIZAS SERVO SELECCIONADO
    FLAG=0;
    enable_interrupts(INT_RDA);
   }
  }
}
//ACEPTO GRABAR SERVOS
void GRABAR(void){
  enable_interrupts(GLOBAL);
  while(TRUE){
    if(FLAG==1){
    Printf("SERVO %u: %Lu Grados...\r\n",NSERVO,POSICION);
    disable_interrupts(INT_RDA);
    AUX=(POSICION*34)+4400; //AQUI OBTIENES LOS TICK'S     
    AUXH=65536-AUX;    //AQUI OBTIENES EL TIEMPO EN ALTO  
    HIGH[NSERVO]=AUXH;  //ACTUALIZA EL SERVO SELECCIONADO
 
    AUX=20000-AUX;   //4ms - (TIEMPO TRANSCURRIDO EN ALTO)
    AUXL=65536-AUX;   //AQUI OBTIENES EL TIEMPO BAJO
    LOW[NSERVO]=AUXL;  //ACTUALIZAS SERVO SELECCIONADO
    if(s[NSERVO]==5){  //MAXIMO A GRABAR 9 POSICIONES DE CADA SERVO 
          //(Depende si se cambio en la matriz de SERVOH,SERVOL)
     printf("SERVO [%u]; Maximo de grabado\r\n",NSERVO);
    }
    else if(HIGH[NSERVO]!=TEMPH[NSERVO] && LOW[NSERVO]!=TEMPL[NSERVO]){//A CAMBIADO LA POSICION?
     SERVOH[s[NSERVO]][NSERVO]=HIGH[NSERVO];         //SE GUARDA EL TIEMPO ALTO
     SERVOL[s[NSERVO]][NSERVO]=LOW[NSERVO];         //------------------- BAJO
     printf("SERVO[%u]; %u grabado(s)\r\n",NSERVO,s[NSERVO]+1);
     s[NSERVO]++;  //INCREMENTA EL LIMITE DE CADA SERVO
    }
    FLAG=0;     //ESPERA OTRA VEZ SI SE HA RESIVIDO UN CAMBIO EN LOS SERVOS
    TEMPH[NSERVO]=HIGH[NSERVO]; //SE GUARDA TEMPORALMENTE EL TIEMPO ALTO DEL SERVO CORRESPONDIENTE
    TEMPL[NSERVO]=LOW[NSERVO]; //----------------------------------------------------------------
    if(s[0]==5 && s[1]==5 && s[2]==5 && s[3]==5 && s[4]==5){//MAXIMO DE GRABAR 5 SERVOS (TAMBIEN,
                  //SE CAMBIA LOS PARAMETROS DEPENDE
                  //SI CAMBIO SERVOH Y SERVOL
     printf("SE GRABO TODOS LOS PASOS\r\n");
     printf("DESEA EMPEZAR LO GRABADO? \r\n");
     while(!input(PIN_A0)); //NECESITAMOS PRESIONAR EL PUSH PARA EMPEZAR
     SW=1;
PUNTO_INICIO:
     printf("SE REINICIO LA POSICION DE LOS SERVOS\r\n");
     PULSO=0;
     x=0;
     while(TRUE){
      if(PULSO>=75){
       for(NSERVO=0;NSERVO<=4;NSERVO++){ //ACTUALIZA PARA EL PRIMER MOVIMIENTO
        HIGH[NSERVO]=SERVOH[x][NSERVO]; //ALTO
        LOW[NSERVO]=SERVOL[x][NSERVO];  //BAJO
       }
       set_timer1(get_timer1());
       enable_interrupts(GLOBAL);
       PULSO=1;
       x++;
       if(x>=5){  //HA LLEGADO AL LIMITE DONDE SE GRABO LOS SERVOS//TMB CAMBIA ESTE
           //PARAMETRO SI SE CAMBIO SERVOH Y SERVOL
        goto PUNTO_INICIO;    //OTRA VEZ
       }
      }
 
     }
    }
    enable_interrupts(INT_RDA);
   }
  } 
}
//MENU PRINCIPAL
void main(void){
  config();
  printf("INILIZAR SERVOS\r\n");
  for(NSERVO=0;NSERVO<=4;NSERVO++){
   printf("SERVO[%u]; ",NSERVO); 
   POSICION=getc(); 
   printf("%Lu grados...\r\n",POSICION);
   AUX=(POSICION*34)+4400; //AQUI OBTIENES LOS TICK'S     
   AUXH=65536-AUX;    //AQUI OBTIENES EL TIEMPO EN ALTO  
   INH[NSERVO]=AUXH;  //ACTUALIZA EL SERVO SELECCIONADO
   AUX=20000-AUX;   //2.5ms - (TIEMPO TRANSCURRIDO EN ALTO)
   AUXL=65536-AUX;   //AQUI OBTIENES EL TIEMPO BAJO
   INL[NSERVO]=AUXL;  //ACTUALIZAS SERVO SELECCIONADO
  }
  PUNTO_DE_INICIO();
  printf("Desea Grabar Servos? (REC)\r\n");
  printf("Desea Manipular Servos Manualmente? (MANUAL)\r\n");
RESPUESTA:
  printf("R= ");
  Respuesta=getc();
  switch (Respuesta){
   case 'G': printf("REC\r\n"); GRABAR();break;
   case 'M': printf("MANUAL\r\n");MANUAL(); break;
   default: printf("Intente otra vez\r\n"); goto RESPUESTA;
  }
}

El archivo de abajo tiene una imagen y la simulacion en proteus el programa necesario para controlarlo.
*Nota: Si no se abre, podria ser su version ya que estoy usando proteus 7.5 Sp3
si tienen uno mas abajo no creo que se abra...!
 

Adjuntos

que tal george muy buenos ejemplos me han ayudado mucho a comprender este lenguaje para pics

ahora tengo una pequeña duda que espero me puedas resolver, quiero hacer una matriz de leds pero con la informacion de las letras guardada en una 24lc256, lo que necesito es saber si la libreria que utilizas en un ejemplo anterior (24256.c) funciona en pics que no manejan i2c por hardware como el 16f84a y si es asi me la puedes pasar ya que no la encuentro entre los archivos del ccs que tengo instalado.

gracias y espero tu respuesta
 
Hola, estoy intentando compilar codigo desde mplab 8.4 en CCS, pero cuando le doy al boton de "build all" o "make project" se me abre el compilador PCWHD. Esto es normal o se puede compilar en mplab?
En qualquier caso, me dijeron que tenia que usar mplab porque al programar el micro seria mas facil hacerlo con el mplab. Una vez creado el *.hex se puede usar el mplab para programar el mico?. A ver si pueden ayudarme gracias.
 
Desde el entorno CCs puedes compilar tu programa,perfectamente,
Aunque;si con mplab usando un plugins...deberias poder utilizarlo sin problem..
Pero es igual de facil con el CCs directo..
Despues si tienes picstar o pickit, solo debes importar el .HEx desde mplab..y listo
El CC s compila y te genera .HEX y el cof..
Suerte..
 
bueno aqui esta lo prometido...jeje...este pequeño programa esta en forma de control.
se dara un archivo para word, donde viene explicado el programa.
y se dara el programa.
hola, revise tu proyecto y esta muy interesanre, pero como me falta un poco de experiencia en programacion quisiera a ver si me puedes mandar el codigo fuente del este progama, y que compilador usaste? te lo agradeceria mucho, mi mail
NoLeíLasPolíticasDelForoYPorEsoMeEditaronElMensaje@ForosDeElectrónica.Com
 
Última edición por un moderador: