PWM in PIC16F877A EN/ES

Recall from our theoretical article that to generate a PWM signal is necessary a square wave which must have a defined frequency that is not affected by the variation of the useful cycle, the CCP module what it does is to modulate the signal in pulse amplitude.

That is why the CCP module works in conjunction with the TMR2 timer, if we remember in our article on TMR2 we learned how to generate frequencies and the factors that define its value in TMR2. This is important because it is not enough to modulate in PWM because the frequency to use will depend on the application so you must take into account both the modulation and the frequency of the wave and for this TMR2 will always be used as a complement to CCP.

The CCP module is an 8-bit register which means that it can handle values between 0 and 255 that we can interpret between 0 and 100% thus defining the percentage of the useful cycle in PWM, ie, when the value is 255 will be delivering a useful cycle of 100% and when it is 0 will be 0%, obviously this is equivalent for intermediate values. If we want to vary the pulse width we can do it by varying the PWM value and this can be done by the instruction set_pwmx_duty(value from 0 to 255) we must replace the x by the number of the module used.

Recordemos de los visto en nuestro artículo teórico que para generar una señal PWM es necesario una onda cuadrada la cual debe tener una frecuencia definida que no se ve afectada por la variación del ciclo útil, el módulo CCP lo que hace es modular la señal en amplitud de pulso.

Es por ello que el módulo CCP trabaja en conjunto con el temporizador TMR2, si recordamos en nuestro artículo sobre TMR2 aprendimos a generar frecuencias y los factores que definen su valor en TMR2. Esto es importante ya que no basta con modular en PWM pues la frecuencia a usar dependerá de la aplicación así que se debe tener en cuenta tanto la modulación como la frecuencia de la onda y para esto siempre se usará TMR2 como complemento a CCP.

El modulo CCP es un registro de 8bits lo que implica que puede manejar valores entre 0 y 255 que podemos interpretar entre 0 y 100% definiendo así el porcentaje del ciclo útil en PWM, es decir, cuando el valor sea 255 se estará entregando un ciclo útil del 100% y cuando sea 0 será de 0%, obviamente esto se hace equivalente para valores intermedios. Si deseamos variar el ancho de pulso lo podemos hacer variando el valor de PWM y esto se puede hacer mediante la instrucción set_pwmx_duty(valor de 0 a 255) debemos reemplazar la x por el número del módulo utilizado.

For our application example we will generate a PWM signal using the CCP1 module, we will connect it to a led to see the effects caused by the pulse variation (since it is a simulator the effect is not appreciated in real time which gives us an advantage of appreciation), we will also connect the signal to a frequency meter to verify that the frequency is not affected by the pulse variation (except when we place the useful cycle at the value 0) and an oscilloscope to observe how the wave changes shape.

To produce the variation in pulse width we will use an ADC, we will make the potentiometer value produce an equivalent variation in percentage in PWM and we will use a new library (<map_function.c>) to make the equivalent conversion by means of a rule of 3.

We will be showing at all times the results by a LCD in which we will be observing the PWM value in bits and the percentage of the useful cycle in each value.

Para nuestro ejemplo de aplicación vamos a generar una señal PWM usando el módulo CCP1, la conectaremos a un led para ver los efectos que causa la variación del pulso (dado que es un simulador el efecto no se aprecia en tiempo real lo que nos da una ventaja de apreciación), también conectaremos la señal a un medidor de frecuencias para comprobar que la frecuencia no se ve afectada por la variación del pulso (salvo cuando situamos el ciclo útil en el valor 0) y un osciloscopio para observar como la onda cambia de forma.

Para producir la variación en el ancho de pulso usaremos un ADC, haremos que el valor del potenciometro produzca una variación equivalente en porcentaje en PWM y nos apoyaremos con una nueva librería (<map_function.c>) para hacer la conversión equivalente mediante una regla de 3.

Estaremos mostrando en todo tiempo los resultados por una LCD en la cual estaremos observando el valor de PWM en bits y el porcentaje del ciclo útil en cada valor.

We start our code by configuring the usual parameters taking into account that we will use ADC and LCD20x4 so we also define their configuration and add the library that will allow us to use the rule of 3 for the equivalence between the PWM register value and the percentage of the duty cycle. We also create variables to store adc and pwm values.

Iniciamos nuestro código configurando los parámetros habituales tomando en cuenta que usaremos ADC y LCD20x4 por lo que definimos también la configuración de los mismos y añadimos la librería que nos facilitará usar regla de 3 para la equivalencia entre el valor del registro PWM y el porcentaje del ciclo útil. Además creamos las variables para almacenar valores del adc y pwm.

#include 

#device ADC = 10

#fuses HS,NOWDT,NOPROTECT,NOPUT,NOLVP,BROWNOUT

#use delay(clock=20M)

#use standard_io(D)

#define LCD_DB4  PIN_D4

#define LCD_DB5  PIN_D5

#define LCD_DB6  PIN_D6

#define LCD_DB7  PIN_D7

#define LCD_RS   PIN_D2

#define LCD_E    PIN_D3

#include 

#include <map_function.c

long adc_value;

int pwm_value;

int percent;

In the first lines of the main program we initialize the LCD, we define the TMR2 parameters to generate the frequency we want (the values are obtained by doing the calculations described in the article dedicated to TMR2 but in this case we do not activate the TMR2 interrupt.

We also configure the CCP1 module to work in PWM mode, set its value to 0 (because we are going to vary it with the ADC) and configure the ADC.

En las primeras líneas del programa principal inicializamos la LCD, definimos los parámetros de TMR2 para generar la frecuencia que deseamos (los valores los obtenemos haciendo los cálculos descritos en el artículo dedicado a TMR2) pero en este caso no activamos la interrupción por TMR2.

Configuramos además el modulo CCP1 para trabajar en modo PWM, fijamos su valor en 0 (porque lo vamos a variar con el ADC) y configuramos el ADC.

void main()

{

   lcd_init();

   setup_timer_2(t2_div_by_4, 255, 1);

   setup_ccp1(ccp_pwm);

   setup_adc_ports(AN0);

   setup_adc(adc_clock_internal);

   set_pwm1_duty(0);

The next thing is to read the ADC value and calculate the equivalent value to be loaded in the PWM, we must remember that the ADC varies from 0 to 1023, the PWM varies from 0 to 255 and the duty cycle varies from 0 to 100%.

By means of the map() function we can apply the rule of 3 that returns the equivalent value, for it inside the parenthesis we introduce the values separated by a comma:

The first value is the one that has the first variable in real time (only the name of the variable is written), the second data is the minimum value of the first variable, the third data is the maximum value of the first variable, the fourth data is the minimum value of the second variable, the fifth data is the maximum value of the second variable and the result is the value of the second variable in real time.

Once the values are obtained, they are displayed on the LCD.

Lo siguiente es leer el valor del ADC y calcular el valor equivalente que se cargará en el PWM, debemos recordar que el ADC varía de 0 a 1023, el PWM varía de 0 a 255 y el ciclo de trabajo varía de 0 a 100%.

Mediante la función map() podemos aplicar la regla de 3 que devuelve el valor equivalente, para ello dentro del parentesis introducimos los valores separados por una coma:

El primer valor es el que posee la primera variable en tiempo real (solo se escribe el nombre de la variable), el segundo dato es el valor mínimo de la primera variable, el tercer dato es el valor máximo de la primera variable, el cuarto dato es el valor mínimo de la segunda variable, el quinto dato e el valor máximo de la segunda variable y el resultado es el valor de la segunda variable en tiempo real.

Una vez obtenidos los valores los mostramos en la LCD.

 while(true)
  
 {

      set_adc_channel(0);

      delay_us(2);

      adc_value = read_adc();

      pwm_value = map(adc_value, 0, 1023, 0, 255);

      percent = map(pwm_value, 0, 255, 0, 100);

      set_pwm1_duty(pwm_value);
   
      lcd_gotoxy(1,1);

      printf(lcd_putc,"PWM: %u ",pwm_value);

      lcd_gotoxy(1,2);

      printf(lcd_putc,"Percent: %u%% ", percent);

      lcd_gotoxy(1,3);

      printf(lcd_putc,"@electronico - HIVE");

      lcd_gotoxy(1,4);

      printf(lcd_putc,"Original Content");

      delay_ms(50);

   }

}

In our simulation we will turn on the circuit and we will vary the potentiometer from its minimum to its maximum value, we will check with an oscilloscope how the square wave is modified and we will use a frequency meter to see how the frequency is stable even though we modify the pulse width. In addition an LCD will show the PWM value and the % duty cycle.

En nuestra simulación encenderemos el circuito y vamos a variar el potenciometro desde su valor mínimo a su máximo, comprobaremos mediante un osciloscopio la forma en la que es modificada la onda cuadrada y usaremos un medidor de frecuencias para ver como la frecuencia es estable a pesar de que modificamos el ancho del pulso. Además una LCD mostrará el valor del PWM y el % del ciclo de trabajo.