simulacion de pmw

[pablolode]

hola, estoy realisando una simulacion en proteus de una frecuencia  con un ciclo de 1/10 a 1khz, y el pulso en alto me da 14 us en ves de 10us programados,y tampoco simula menos tiempo de los 14us.(con el osciloscopio de proteus). esto es asi en el pic? o solo un error??
estoy usando el 16f628.
y una duda de principiante, como medir frecuencias con mi tester (tiene hasta 200 khz), las puntas van una a masa y la otra a la salida del pulso??.

[migsantiago]

Hola, se me ocurre qué puede estar pasando pero te pregunto antes unas cosas:

- ¿A qué velocidad corre tu PIC16?
- ¿Estás generando el PWM con el módulo CCP o por timers?

[pablolode]

HOLA ,corre a 4mhz con cristal y esta generado por timers

[migsantiago]

Entonces cada instrucción le toma al pic 1us en ejecutarse (4MHz / 4)

Si lees la bandera de desbordamiento del timer e inmediatamente vas y cambias el estado del pin de salida entonces eso te toma como 4 instrucciones, algo similar a los 4us que tienes de defasamiento.

Lo recomendable es usar el PWM por CCP, ése método sí es preciso.

[pablolode]

ok provare con CCP,pero habra alguna explicacion de por que a pesar de que le baje el tiempo del pulso en alto por ejem cualquier valor menor a 14us proteus sige midiendo 14us??

[Suky]

Debe ser la forma de como esta realizado el código que no permite menos de 14us, aparte realizado en C menos control hay al respecto. Coloca #use fast_io(..) al puerto que utilizas para sacar la PWM puede que mejore la precisión en valores tan pequeños.

Saludos!

[migsantiago]

ok provare con CCP,pero habra alguna explicacion de por que a pesar de que le baje el tiempo del pulso en alto por ejem cualquier valor menor a 14us proteus sige midiendo 14us??

No te podría decir sin poder ver el código fuente.

[pablolode]

 es el codigo de ejemplo del maestro VZENER,solo le modifique los tiks minimo medio y alto, ... sospecho tambien de que  son tiempos muy cortos....


****************************************************************
///    Periodo 1 ms (Frecuencia 1 kHz)
//    1 tiks 2us
//    5 ticks 10us
//    AJUSTE DE PULSO
      Ancho Pulso minimo  6us
//    Ancho pulso medio  10us
//    Ancho pulso maximo 20us

//    TMR0 a 1:2 -> 1 RTCC cada 512 us
//                -> 1 Tick cada 512/ 256 = 2us
//                -> 1 ms = (1 x RTCC completas) + (1 * RTCC - 12 ticks)

//   
*/

#include <16f628a.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
#use delay(clock=4000000)
#use standard_io(b)
#use rs232(baud=9600, xmit=PIN_B2, rcv=PIN_B1)

#define PIN_SERVO1 PIN_B0

const int AJUSTE_FINO_DE_RTCC =  12; // 256 - 12= 1 RTCC
const int ticks_PULSO_MINIMO  =   3;
const int ticks_PULSO_MEDIO   =  5;
const int ticks_PULSO_MAXIMO  =  10;
int1 flagRTCC   = 0; // activo c/ 1 rtc completas
int  contRTCC   = 0;
int1 flagSERVO1 = 0; //  marca cuando flag RTCC SE ACTIVO
                              //pin se activo
int  tSERVO1    = ticks_PULSO_MEDIO;

char Keypress=0x00;

[migsantiago]

Por favor pon el código completo 

Ahí solo tenemos la inicialización de las variables.

[pablolode]

si ok,este es


****************************************************************
///  duty cycle 0.01ms @ 1khz
//    T1=10us
//    T2=990us
 
//   TIMER0 a 1:2 _____ 1 rtcc cada 512us
//   T1________________ 1 rtcc = Tcm *prescaler (256-251)= 10us
//   T2________________ 2 rtcc = 1 rtcc +  Tcm*prescaler(256-12)= 1ms


 
//    1 tiks 2us
//    5 ticks 10us
//    AJUSTE DE PULSO
      Ancho Pulso minimo  6us
//    Ancho pulso medio  5us
//    Ancho pulso maximo 100us

//    TMR0 a 1:2 -> 1 RTCC cada 512 us
//                -> 1 Tick cada 512/ 256 = 2us
//                -> 1 ms = (1 x RTCC completas) + (1 * RTCC - 12 ticks)

//   
*/

#include <16f628a.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
#use delay(clock=4000000)
#use standard_io(b)
#use rs232(baud=9600, xmit=PIN_B1, rcv=PIN_B2)

#define PIN_SERVO1 PIN_B0

const int AJUSTE_FINO_DE_RTCC =  12; // 256 - 12= 1 RTCC
//AJUSTE PMW
const int ticks_PULSO_MINIMO  =   3; //6us
const int ticks_PULSO_MEDIO   =  5; //10 us
const int ticks_PULSO_MAXIMO  =  50; //100us

int1 flagRTCC   = 0; // activo c/ 1 rtc completas
int  contRTCC   = 0;
int1 flagSERVO1 = 0; //  marca cuando flag RTCC SE ACTIVO
                     //pin se activo
int  tSERVO1    = ticks_PULSO_MEDIO;

char Keypress=0x00;

void eco_servos(void);

#int_rda
void rda_isr() {

   Keypress=0x00;
   if(kbhit()){
      Keypress=getc();
   }
}

#int_RTCC
RTCC_isr(){

   ++contRTCC;
   if(contRTCC==1){
      set_TIMER0(AJUSTE_FINO_DE_RTCC);
   }
   if(contRTCC==2){
      flagRTCC=1;
      contRTCC=0x00;
   }
}

void eco_servos(void){
   printf("S=%u\r\n",tSERVO1);
}

void main() {

   int ValTIMER0;

   setup_counters(RTCC_INTERNAL,RTCC_DIV_2);

   enable_interrupts(int_rda);
   enable_interrupts(global);


   printf("\r\n\COMANDO PMW \r\n\r\n");
   eco_servos();

   set_TIMER0(0);

   enable_interrupts(INT_RTCC);


   do {
   
      // DISPARO DEL PULSO PWM

      if(flagRTCC==1){
         flagRTCC=0;
         output_high(PIN_SERVO1);
         flagSERVO1=1;   
      }

      // CONTROL DE ANCHO DEL PULSO PWM
      if(flagSERVO1==1){
         valTIMER0 = get_TIMER0();
         if(valTIMER0>tSERVO1){
            flagSERVO1=0;
            output_low(PIN_SERVO1);
         }   
      }
   
      // CONTROL DESDE LA RS-232
     
      if(Keypress!=0x00){
         switch(Keypress){
            // Periodos Prefijados

            case '1': tSERVO1=ticks_PULSO_MINIMO;
                      break;
            case '2': tSERVO1=ticks_PULSO_MEDIO;
                      break;
            case '3': tSERVO1=ticks_PULSO_MAXIMO;
                      break;
            case '+': if(++tSERVO1>ticks_PULSO_MAXIMO){
                        tSERVO1=ticks_PULSO_MAXIMO;
                      }
                      break;
            case '-': if(--tSERVO1<ticks_PULSO_MINIMO){
                        tSERVO1=ticks_PULSO_MINIMO;
                      }
                      break;
            case 'r': eco_servos();
                      break;
        }
         
         Keypress=0x00;
      }


   } while (TRUE);

}

[Suky]

Sencillo, como estas usando interrupción para detectar el tiempo, mientras se guarda el contexto en la interrupción, se setea el flag correspondiente y vuelve al main ejecuta varias instrucciones que no te permiten tener pleno control de la señal. Por ello es mejor usar el módulo CCP para la generación de PWM.


Saludos!

[migsantiago]

Como dice Suky, cuando se atiende la interrupción se hacen muchas cosas que toman tiempo al micro.

Lo mejor es usar el PWM por hardware. Hay muchos ejemplos en el foro.

[pablolode]

ok ,voy a provar por el lado del modulo CCP,gracias