Biblioteca de PWM para PIC18F4520

Paulo Estêvão · 21 de junho de 2017

Olá gente.

Tudo bem?

Estou fazendo um projeto de controle de velocidade de um motor com PWM e também uso interrupção junto a ele.

Gostaria de saber se alguém pode me disponibilizar uma biblioteca para usar o PWM, pois quando uso a do PIC o programa começa a travar e não funciona.

No mais, obrigado!

.if · 21 de junho de 2017

Geralmente o pwm do hw trabalha "sozinho" bastando programá-lo corretamente. Algo interessante a se fazer é publicar o fonte e fornecer mais detalhes. Mas não e nunca sem antes entender exatamente como funciona/programar o hw do mc a nível de bit se for o caso. Portanto penso que não é "a biblioteca" que vai resolver seu problema e sim, digamos.. algo mais profundo.

Agora se estiver fazendo pwm por sw, aí sim, hás de elaborar um sincronismo entre interrupt e ela. De novo, analise profundamente..

abç

Paulo Estêvão · 21 de junho de 2017

BIBLIOTECA DO DS1302

#include <p18f4520.h>

#define TRIS_RST TRISAbits.TRISA0
#define TRIS_SCLK TRISAbits.TRISA1
#define TRIS_IO TRISAbits.TRISA2

#define PORT_IO PORTAbits.RA2

#define RST LATAbits.LATA0
#define SCLK LATAbits.LATA1
#define IO LATAbits.LATA2

void write_byte(unsigned char Byte)                //Escrever byte
{
unsigned char i;                       //variavel de repetição
TRIS_IO=0;                            //Saida de dados

for(i=0;i<=7;++i)                       //repete 8 vezes (8 bits)
{
IO=Byte&0x01;                       //Envia para saida a posição (i) do Byte (bit (i))
Byte>>=1;                     //Empurra Byte para a direita (deslocamento de bits)
SCLK=1;                           //Faz o Clock para a transmissão de dados
SCLK=0;                           //idem

}
}

void write_ds1302(unsigned char Byte,unsigned char Data)
{
RST=1;                           //CE em high para inicio da transmissão de dados
write_byte(Byte);                       //Escreve Byte (endereço)
write_byte(Data);                       //Escreve Data (dados)
RST=0;                           //Termina transmissão
}

unsigned char read_ds1302(unsigned char Byte)
{
unsigned char i,Data;

TRIS_SCLK=0;                       //SCLK output
TRIS_RST=0;                           //CE output
RST=1;                           //CE em high para inicio da transmissão de dados

write_byte(Byte);                       //Escreve endereço do dado a ser lido
TRIS_IO=1;                           //Tris_io como input (entrada de dados)
Data=0;                           //reseta variavel
for(i=0;i<=6;i++)
{
if(PORT_IO==1)                       //Se for recebido nivel alto
   {Data+=0x80;}                       //escreve na variavel data no bit mais significativo (1000 0000)
Data>>=1;                     //Desloca para esquerda
SCLK=1;
       Delay1KTCYx(1);
   SCLK=0;               //Clock               //Aqui sua função para o delay de 1 micro segundo
SCLK=0;
       Delay1KTCYx(1);
   SCLK=0;                       //Clock
                   //Delay 1uS
}
RST=0;                           //Fim da transmissão

return(Data); //Função retorna (data)
}

void ds1302_init(void)
{
unsigned char j;
TRIS_IO=0;
TRIS_SCLK=0;
TRIS_RST=0;

RST=0;
Delay1KTCYx(1);
SCLK=0;
Delay1KTCYx(1);
write_ds1302(0x8E,0);
write_ds1302(0x90,0xA4);
j=read_ds1302(0x81);
if((j & 0x80)!=0)
{
write_ds1302(0x80,0);
}
}

unsigned char get_bcd(unsigned char Data)    //Transforma decimal para bcd
{
unsigned char NibleH,NibleL;
NibleH=Data/10;
NibleL=Data-(NibleH*10);
NibleH<<=4;
return(NibleH|NibleL);           //Retorna nible mais e significativo e nible menos significativo
}
unsigned char rm_bcd(unsigned char Data)   //Transforma bcd para decimal
{
unsigned char i;
i=Data;
Data=((i>>4)&0x0F)*10;
Data=Data+(i&0x0F);
return(Data);               //Retorna data
}

void set_datetime(unsigned char day,unsigned char mth,unsigned char year,unsigned char dow,unsigned char hr,unsigned char min, unsigned char sec)
{
TRIS_SCLK=0;
TRIS_RST=0;
write_ds1302(0x86,get_bcd(day));
write_ds1302(0x88,get_bcd(mth));
write_ds1302(0x8c,get_bcd(year));
write_ds1302(0x8a,get_bcd(dow));
write_ds1302(0x84,get_bcd(hr));
write_ds1302(0x82,get_bcd(min));
write_ds1302(0x80,get_bcd(sec));
}

unsigned char get_day(void)
{
return(rm_bcd(read_ds1302(0x87)));
}
unsigned char get_mth(void)
{
return(rm_bcd(read_ds1302(0x89)));
}
unsigned char get_year(void)
{
return(rm_bcd(read_ds1302(0x8D)));
}
unsigned char get_dow(void)
{
return(rm_bcd(read_ds1302(0x8B)));
}
unsigned char get_hr(void)
{
return(rm_bcd(read_ds1302(0x85)));
}
unsigned char get_min(void)
{
return(rm_bcd(read_ds1302(0x83)));
}
unsigned char get_sec(void)
{
return(rm_bcd(read_ds1302(0x81)));
}

void rtc_ram_write(unsigned char address, unsigned char data)
{
write_ds1302(address, data);
}

unsigned char rtc_ram_read(unsigned char address)
{
return(read_ds1302(address));
}

BIBLIOTECA DO LCD

/******************************************************************************
*
* Curso CETEL de Microcontroladores (PIC18F4520)
*
******************************************************************************
* Nome do Arquivo: displayLCD.h
* Dependencias: Veja seção INCLUDES
* Processador: PIC18F4520
* Opção de Clock: HS 20MHz (externo)
* Compilador: C18 v3.20 ou superior
* Empresa: SENAI - CETEL
*
* Plataforma: Kit CETEL v1.0
*
* Autor: Diogo Rafael de Oliveira Xavier
*
* Data: v1 - 29/Jul/2010
* v2 - 20/Out/2010
*
*
* Descrição: Modificação da biblioteca fornecida no tutorial Comunicação de
* LCD em 4 vias - Autor: Eduardo Souza Ramos. A biblioteca utilizada
* no tutorial trata da comunicação com display de LCD por meio de
* 4-bits (length), utilizando o PORTD tanto para os 4 bits de dados
* quanto para os 3 bits de controle (RS, RW e E).
* No projeto do Kit CETEL o display LCD pode ser ligado a qualquer portas
* digitais do PIC 18F4520. Esta biblioteca utiliza
* os seguintes pinos para comunicação com o display LCD:
*
* PIC18F4520(pino):: Display LCD
* RD4 (27) :: B4
* RD5 (28) :: B5
* RD6 (29) :: B6
* RD7 (30) :: B7
* RD2 (21) :: RS
* RD3 (22) :: E1
* GND :: R/W
RE1(9) :: LCD-ON
* OBS: o pino R/W do display é ligado no Kit CETEL ao GND, assim
* o LCD opera no modo escrita(Write) o tempo todo.
* Notas:
* - Essa bliblioteca de rotinas foi escrita pensando em um LCD
* 16x2 FDCC1602E implementado com o controlador SPLC780D, mas pode
* ser utilizado com qualquer LCD 16x2 com controladores equivalentes
* como, por exemplo, o controlador Hitachi HD44780 LCD controller.
*
* -- O sincronismo da comunicação com o LCD:
* As temporizações entre o envio de comandos, não foi utilizado
* o bit de Busy do LCD, mas sim, através de funções de atraso.
* A função utilizada foi a Delay10KTCYx() da bilioteca padrão C18
* delays.h que aparece na seção INCLUDE deste arquivo.
* Os tempos de delay escolhidos foram utilizando-se um cristal de 20MHz,
* caso se utilize um cristal de valor diferente talvez haja a necessidade de
* alteração nas rotinas de tempo para que as mesmas se adequem ao
* tempo mínimo requerido pelo display de LCD (5ms o de sincronismo e
* 15ms o inicial).
*****************************************************************************/

/** I N C L U D E S **********************************************************/
#include <p18f4520.h>

/** D E F I N E S ************************************************************/
#define D4 PORTDbits.RD4 // Define a porta RD4 como D4
#define D5 PORTDbits.RD5 // Define a porta RD5 como D5
#define D6 PORTDbits.RD6 // Define a porta RD6 como D6
#define D7 PORTDbits.RD7 // Define a porta RD7 como D7
#define RS_PIN PORTDbits.RD2 // Define a porta RD2 como RS_PIN
#define E_PIN PORTDbits.RD3 // Define a porta RD3 como E_PIN

/** P R O T O T I P O S P R I V A D O S ***********************************/
void envia_nibble_lcd(unsigned int dado);
void envia_byte_lcd(unsigned char endereco, unsigned int dado);
void limpa_lcd(void);
void inicializa_lcd(void);
void escreve_lcd(unsigned char c);
void putsXLCD(char *buffer);
void putrsXLCD(const rom char *buffer);

/** F U N C O E S ************************************************************/

/******************************************************************************
* Funcao: void envia_nibble_lcd(unsigned int dado)
* Entrada: dado: dado que terá seu nibble inferior enviado ao display LCD
* Saída: Nenhuma (void)
* Descrição: Esta rotina lê o "Nibble" inferior de uma variável e envia para o LCD.
*****************************************************************************/
void envia_nibble_lcd(unsigned int dado)
{
if(dado&0b00000001)D4=1;
else D4=0;
if(dado&0b00000010)D5=1;
else D5=0;
if(dado&0b00000100)D6=1;
else D6=0;
if(dado&0b00001000)D7=1;
else D7=0;

E_PIN = 1;
Delay1TCY();//Aguarda 200nS
Delay1TCY();//Aguarda 200nS
Delay1TCY();//Aguarda 200nS
Delay1TCY();//Aguarda 200nS
Delay1TCY();//Aguarda 200nS
E_PIN = 0;

return;
}

/******************************************************************************
* Funcao: void envia_byte_lcd(unsigned char endereco, unsigned int dado)
* Entrada: endereço: indica se o dado enviado será uma instrução ou caractere
* dado: dado ou instrução que será enviado ao display LCD
* Saída: Nenhuma (void)
* Descrição: Esta rotina irá enviar um dado ou um comando para o LCD conforme abaixo:
* ENDEREÇO = 0 -> a variável DADO será uma instrução
* ENDEREÇO = 1 -> a variável DADO será um caractere
*****************************************************************************/
void envia_byte_lcd(unsigned char endereco, unsigned int dado)
{
if(endereco == 0)RS_PIN = 0;
else RS_PIN = 1;
Delay100TCYx(5);//Aguarda 100uS
E_PIN = 0;
envia_nibble_lcd(dado>>4);
envia_nibble_lcd(dado & 0x0f);
Delay100TCYx(2);//Aguarda 40uS
return;
}

/******************************************************************************
* Funcao: void limpa_lcd(void)
* Entrada: Nenhuma (void)
* Saída: Nenhuma (void)
* Descrição: Esta rotina limpa o LCD.
*****************************************************************************/
void limpa_lcd(void)
{
envia_byte_lcd(0,0x01); // Envia instrução para limpar o LCD
Delay10KTCYx(1); // Aguarda 2ms para estabilizar o LCD
return; // Retorna ao ponto de chamada da função
}

/******************************************************************************
* Funcao: void inicializa_lcd(void)
* Entrada: Nenhuma (void)
* Saída: Nenhuma (void)
* Descrição: Configura os parametros de comunicação
* com o display, tais como:
* - modo de operação (4 ou 8 data bits)
* - tipo de cursor
* - tamanho da fonte
*****************************************************************************/
void inicializa_lcd(void)
{
D4 = 0; // Garante que o pino DB4 estão em 0 (low)
D5 = 0; // Garante que o pino DB5 estão em 0 (low)
D6 = 0; // Garante que o pino DB6 estão em 0 (low)
D7 = 0; // Garante que o pino DB7 estão em 0 (low)
RS_PIN = 0; // Garante que o pino RS estão em 0 (low)
E_PIN=0; // Garante que o pino ENABLE estão em 0 (low)
Delay10KTCYx(75); // Aguarda 15ms para estabilizar o LCD
envia_nibble_lcd(0x03);// Envia comando para inicializar o display
Delay10KTCYx(25); // Aguarda 5ms para estabilizar o LCD
envia_nibble_lcd(0x03);// Envia comando para inicializar o display
Delay10KTCYx(25); // Aguarda 5ms para estabilizar o LCD
envia_nibble_lcd(0x03);// Envia comando para inicializar o display
Delay10KTCYx(25); // Aguarda 5ms para estabilizar o LCD
envia_nibble_lcd(0x02);// CURSOR HOME - Envia comando para zerar o contador de
// caracteres e retornar à posição inicial (0x80).
Delay10KTCYx(5); // Aguarda 1ms para estabilizar o LCD
envia_byte_lcd(0,0x28);// FUNCTION SET - Configura o LCD para 4 bits,
// 2 linhas, fonte 5X7.
envia_byte_lcd(0,0x0c);// DISPLAY CONTROL - Display ligado, sem cursor
limpa_lcd(); // Limpa o LCD
envia_byte_lcd(0,0x06);// ENTRY MODE SET - Desloca o cursor para a direita
return; // Retorna ao ponto de chamada da função
}

/******************************************************************************
* Funcao: void escreve_lcd(unsigned char c)
* Entrada: c = caractere que será enviado ao LCD
* Saída: Nenhuma (void)
* Descrição: Esta rotina envia um caractere ao LCD.
*****************************************************************************/
void escreve_lcd(unsigned char c)
{
envia_byte_lcd(1,c);
}

/******************************************************************************
* Funcao: void putrsXLCD(const rom char *buffer)
* Entrada: *buffer: apontador para string na memoria de programa(ROM)
* Saída: Nenhuma (void)
* Descrição: Essa rotina copia uma string terminada com caracter nulo
* da memoria de programa do microcontrolador para o display de LCD.
* A string apontada por *buffer é copiada no display a partir da
* posição da memoria RAM do display escolhida com a função
* envia_byte_lcd().
*****************************************************************************/
void putrsXLCD(const rom char *buffer)
{
while(*buffer) // escreve dados no LCD ate achar caracter nulo
{
escreve_lcd(*buffer); // escreve caracter no LCD
buffer++; // incrementa apontador
}
}

/******************************************************************************
* Funcao: void putsXLCD(char *buffer)
* Entrada: *buffer: apontador para string na memoria de dados(RAM)
* Saída: Nenhuma (void)
* Descrição: Essa rotina copia uma string terminada com caracter nulo
* da memoria de dados do microcontrolador para o display de LCD.
* A string apontada por *buffer é copiada no display a partir da
* posição da memoria RAM do display escolhida com a função
* envia_byte_lcd().
*****************************************************************************/
void putsXLCD(char *buffer)
{
while(*buffer) // escreve dados no LCD ate achar caracter nulo
{
escreve_lcd(*buffer); // escreve caracter no LCD
buffer++; // incrementa apontador
}
}

PROGRAMAÇÃO PRINCIPAL

/**************************** I N C L U D E S ********************************/
#include <p18F4520.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <delays.h>
#include <I2C.h>
#include <pwm.h>
#include <timers.h>
#include "displayLCD.h"

#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config BOREN = OFF
#pragma config WDT = OFF

/******************************************************************************/

/************************ D E F I N I Ç Õ E S **************************************/

#define LOAD_TMR0 63193 // Valor carregado no TIMER para 0,2s

/******************************************************************************/

/*********************** V A R I Á V E I S G L O B A I S ***********************************/

unsigned char inicio[20]; // VETOR PARA ESCRITA DE INFORMAÇÃO NO LCD
unsigned char Liga_escada[17]; // VETOR QUE RECEBE O HORÁRIO DE LIGAR A ESCADA
unsigned char Desliga_escada[17];// VETOR QUE RECEBE O HORÁRIO DE DESLIGAR A ESCADA
unsigned char Horas[17]; // VETOR QUE RECEBE O HORÁRIO DO DS1302
unsigned char auxiliar = 0; // VARIÁVEL QUE AUXULIA NA CONFIGURAÇÃO
unsigned char alto = 0; // VARIÁVEL PARA INCREMENTO DE TEMPO E SELEÇÃO
signed char baixo = 0; //VARIÁVEL PARA DECREMENTO DE TEMPO E SELEÇÃ0
unsigned char segs = 0;//VARIÁVEL DOS SEGUNDOS
unsigned char mins = 0;//VARIÁVEL DOS MINUTOS
unsigned char hora = 0;//VAROÁVEL DAS HORAS
unsigned char seg1 = 0;//VARIÁVEL DOS SEGUNDOS
unsigned char min1 = 0;//VARIÁVEL DOS MINUTOS
unsigned char hor1 = 0;//VAROÁVEL DAS HORAS
unsigned char aux1 = 0; // VARIÁVEL QUE AUXULIA NA LÓGICA DA configuração DOS HORÁRIOS
unsigned char aux2 = 0; // VARIÁVEL QUE AUXULIA NA LÓGICA DA configuração DOS HORÁRIOS
unsigned char aux3 = 0; // VARIÁVEL QUE AUXULIA NA LÓGICA DA configuração DOS HORÁRIOS
unsigned char sent = 0; // VARIÁVEL QUE AUXULIA DAS CONFIGURAÇÕES DO SENTIDO
unsigned char interrupcao = 0; //VARIÁVEL RESPONSÁVEL PELAS INTERRUPÇÕES
unsigned char cont = 0; // VARIÁVELQUE AUXILIA NA GERAÇÃO DAS INTERRUPÇÕES
unsigned char controle = 0; // VARIÁVEL QUE AUXULIA NA LÓGICA DO ACIONAMENTO/DESACIONAMENTO DO CONTROLE

/****************************************************************************************************/

/*************** P R O T O T I P O S D E F U N Ç Õ E S A U X I L I A R E S **********************/

void configuração(void); // FUNÇÃO DE CONFIGURAÇÃO DO FUNCIONAMENTO DA ESCADA

void Configura_Interrupcao(void); // FUNÇÃO QUE CONFIGURA INTERRUPÇÕES

void Configura_Relogio(void); //FUNÇAO PARA AUXILIAR NA CONFIGURAÇÃO DO HORÁRIO LIGA/DESLIGA

void Config_Liga_Desliga (void); //FUNÇÃO PARA CONFIGURAR HORÁRIO DE LIGAR E DESLIGAR

void Controle_on_off(void); // FUNÇÃO QUE CONFIGURA SE A ESCADA IRÁ OPERAR NO MODO INTELIGENTE

void Delay100ms(int del); // FUNÇÃO QUE GERA ATRASO DE TEMPO

void Escreve_lcd_desliga(void);//FUNÇÃO QUE MOSTRA NO LCD HORÁRIO DE DESLIGAR

void Escreve_lcd_liga(void) ; //FUNÇÃO QUE MOSTRA NO LCD HORÁRIO DE LIGAR

void Registradores(void); // FUNÇÃO QUE CONFIGURA OS REGIDTRADORES, ENTRE OUTROS

void Sentido(void); // FUNÇÃO QUE CONFIGURA O SENTIDO DA ESCADA ROLANTE

void TRATA_HIGH_INT(void); // FUNÇÃO QUE CONFIGURA AÇÕES A SEREM EXECUTADAS A CADA INTERRUPÇÃO

/****************************************************************************************************/

/*************** P R O T O T I P O S D E F U N Ç Õ E S P A R A F U N C I O N A M E N T O D O D S 1 3 0 2 **************/

void write_byte(unsigned char Byte);

void write_ds1302(unsigned char Byte,unsigned char Data);

unsigned char read_ds1302(unsigned char Byte);

void ds1302_init(void);

unsigned char get_bcd(unsigned char Data);

unsigned char rm_bcd(unsigned char Data);

void set_datetime(unsigned char day,unsigned char mth,unsigned char year,unsigned char dow,unsigned char hr,unsigned char min, unsigned char sec);

unsigned char get_day(void);

unsigned char get_mth(void);

unsigned char get_year(void);

unsigned char get_dow(void);

unsigned char get_hr(void);

unsigned char get_min(void);

unsigned char get_sec(void);

void rtc_ram_write(unsigned char address, unsigned char data);

unsigned char rtc_ram_read(unsigned char address);

/*****************************************************************************************************************************/

void main(void) // FUNÇÃO PRINCIPAL

{

Registradores();

auxiliar = 0;

while(1)

{

if( PORTBbits.RB2 == 1 && controle == 1 ||(strcmp (Horas,Liga_escada) == 0) ) // BOTÃO DE LIGA/DESLIGA E VARIÁVEL DE CONTROLE

   {

PORTCbits.RC6 = 1; // PINO CORREPONDENTE AO MODO SLEEP DO DRIVER DE CONTROLE DO MOTOR
       limpa_lcd();

if(sent == 1)

{

           sprintf(inicio,"ESCADA SUBINDO");
       envia_byte_lcd(0,0x81);
       putsXLCD(inicio);

       sprintf(inicio,"HORA DE DESLIGAR");
       envia_byte_lcd(0,0xC0);
           putsXLCD(inicio);

envia_byte_lcd(0,0x94);
putsXLCD(Desliga_escada);

if(PORTBbits.RB0 == 1)// SENSOR SUOERIOR DA ESCADA ROLANTE(S1)

           {

           OpenTimer2 (TIMER_INT_OFF & T2_PS_1_16 ); // HABILITA TIMER 2
           OpenPWM1(24); // HABILITA PWM 1 E CONFIGURA O PERÍODO/FREQUÊNCIA
           SetOutputPWM1 (SINGLE_OUT, PWM_MODE_1); // CONFIGURA O TIPO DE SAÍDA E O MODO DO PWM 1
           SetDCPWM1(90); //VALOR DE TON(%)>>> CONFIGURA TON E TOFF DO PWM >>> TON GRANDE E TOFF PEQUENO
           interrupcao = 0; // VARIÁVEL QUE GERA AS INTERRUPÇÕES NA PROGRAMAÇÃO
           cont = 0;// VARIÁVELQUE AUXILIA NA GERAÇÃO DAS INTERRUPÇÕES
           PORTCbits.RC0 = 1; //LIGA LED QUE INDICA ESCADA SENDO USADA
           PORTCbits.RC1 = 0; //DESLIGA LED QUE INDICA ESCADA INUTILIZADA
while(PORTBbits.RB0 == 1);
           }

if(interrupcao == 1)// INTERRUPCA0 == 1 SIGNIFICA QUE S2 FICOU UM TEMPO SEM SER ACIONADO

           {

           OpenTimer2(TIMER_INT_OFF & T2_PS_1_16 );// HABILITA TIMER 2
           OpenPWM1(24); // HABILITA PWM 1 E CONFIGURA O PERÍODO/FREQUÊNCIA
           SetOutputPWM1 (SINGLE_OUT, PWM_MODE_1); // CONFIGURA O TIPO DE SAÍDA E O MODO DO PWM 1
           SetDCPWM1(10); //VALOR DE TON(%)>>> CONFIGURA TON E TOFF DO PWM >>> TON PEQUENO E TOFF GRANDE
           PORTCbits.RC0 = 0 ; //DESLIGA LED QUE INDICA ESCADA SENDO USADA
           PORTCbits.RC1 = 1; //LIGA LED QUE INDICA ESCADA INUTILIZADA

}

if(sent == 2)

{

           sprintf(inicio,"ESCADA DESCENDO");
       envia_byte_lcd(0,0x81);
       putsXLCD(inicio);

           sprintf(inicio,"HORA DE DESLIGAR");
       envia_byte_lcd(0,0xC0);
           putsXLCD(inicio);

envia_byte_lcd(0,0x94);
putsXLCD(Desliga_escada);

if(PORTBbits.RB1 == 1)// SENSOR INFERIOR DA ESCADA ROLANTE (S2)

{

           OpenTimer2 (TIMER_INT_OFF & T2_PS_1_16 ); // HABILITA TIMER 2
           OpenPWM1(24); // HABILITA PWM 1 E CONFIGURA O PERÍODO/FREQUÊNCIA
           SetOutputPWM1 (SINGLE_OUT, PWM_MODE_1); // CONFIGURA O TIPO DE SAÍDA E O MODO DO PWM1
SetDCPWM1(90); //VALOR DE TON(%)>>> CONFIGURA TON E TOFF DO PWM >>> TON GRANDE E TOFF PEQUENO
interrupcao = 0; // VARIÁVEL QUE GERA AS INTERRUPÇÕES NA PROGRAMAÇÃO
           cont = 0; // VARIÁVELQUE AUXILIA NA GERAÇÃO DAS INTERRUPÇÕES
           PORTCbits.RC0 = 1; //LIGA LED QUE INDICA ESCADA SENDO USADA
           PORTCbits.RC1 = 0; //DESLIGA LED QUE INDICA ESCADA INUTILIZADA
while(PORTBbits.RB1==1);
           }

if(interrupcao == 1) // INTERRUPCA0 == 1 SIGNIFICA QUE S1 FICOU UM TEMPO SEM SER ACIONADO

{

           OpenTimer2(TIMER_INT_OFF & T2_PS_1_16 );// HABILITA TIMER 2
           OpenPWM1(24); // HABILITA PWM 1 E CONFIGURA O PERÍODO/FREQUÊNCIA
           SetOutputPWM1 (SINGLE_OUT, PWM_MODE_1); // CONFIGURA O TIPO DE SAÍDA E O MODO DO PWM1
           SetDCPWM1(10); //VALOR DE TON(%)>>> CONFIGURA TON E TOFF DO PWM >>> TON PEQUENO E TOFF GRANDE
           PORTCbits.RC0 = 0 ; //DESLIGA LED QUE INDICA ESCADA SENDO USADA
           PORTCbits.RC1 = 1; //LIGA LED QUE INDICA ESCADA INUTILIZADA

}

while (PORTBbits.RB2 == 1 && controle == 1 );

}

if( PORTBbits.RB2 == 1 && controle == 0 ||(strcmp (Horas,Liga_escada) == 0)) //BOTÃO DE LIGA/DESLIGA E VARIÁVEL DE CONTROLE

{
       limpa_lcd();
       CloseTimer2();// DESATIVA O TIMER 2
       ClosePWM1(); // DESATIVA O PWM 1
       PORTCbits.RC6 = 1; // PINO CORREPONDENTE AO MODO SLEEP DO DRIVER DE CONTROLE DO MOTOR
//PORTCbits.RC3 = 1; // PINO CORREPONDENTE AO FUNCIONAMNETO INDEPENDENTE DO MOTOR, COM A MÁXIMA POTÊNCIA
       sprintf(inicio,"CONTROLE EM OFF");
       envia_byte_lcd(0,0x80);
   putsXLCD(inicio);

if ( sent == 1)
{

sprintf(inicio,"ESCADA SUBINDO");
envia_byte_lcd(0,0x90);
putsXLCD(inicio);

}

if ( sent == 2)
{

sprintf(inicio,"ESCADA DESCENDO");
envia_byte_lcd(0,0x90);
putsXLCD(inicio);

}

Delay100ms(2);
while( PORTBbits.RB2 == 1 && controle == 0 );

}

if( PORTBbits.RB2 == 0 ||(strcmp (Horas,Desliga_escada) == 0)) // BOTÃO LIGA/DESLIGA EM DESLIGADO

   {
       limpa_lcd();
       CloseTimer2(); // DESATIVA O TIMER 2
       ClosePWM1(); // DESATIVA O PWM 1
       PORTCbits.RC0 = 0 ; //DESLIGA LED QUE INDICA ESCADA SENDO USADA
       PORTCbits.RC1 = 1; //LIGA LED QUE INDICA ESCADA INUTILIZADA
   //   PORTCbits.RC3 = 0; // PINO CORREPONDENTE AO FUNCIONAMNETO INDEPENDENTE DO MOTOR
PORTCbits.RC6 = 0; // PINO CORREPONDENTE AO MODO SLEEP DO DRIVER DE CONTROLE DO MOTOR

       sprintf(inicio,"ESCADA DESLIGADA");
   envia_byte_lcd(0,0x80);
   putsXLCD(inicio);

sprintf(inicio,"HORA DE LIGAR");
envia_byte_lcd(0,0xC1);
putsXLCD(inicio);

envia_byte_lcd(0,0x94);
putsXLCD(Liga_escada);

Delay100ms(2);
while( PORTBbits.RB2 == 0 && PORTBbits.RB3 == 0 );

}

if(PORTBbits.RB3 == 1 && PORTBbits.RB2 == 0 || PORTBbits.RB3 == 1 && (strcmp (Horas,Desliga_escada) == 0) ) // BOTÃO DE CONFIGURAÇÃO E BOTÃO LIGA/DESLIGA EM DESLIGADO

{

   auxiliar = 0;
       interrupcao = 0;
       cont = 0;
       configuração();
       while(PORTBbits.RB3 == 1 && PORTBbits.RB2 == 0) ;

}

void configuração (void) // FUNÇÃO QUE CONFIGURA OS PARAMETROS DO FUNCIONAMENTO DA ESCADA

{

aux1 = 0;
limpa_lcd();

while(1)

{

       sprintf(inicio,"configuração");
   envia_byte_lcd(0,0x82);
   putsXLCD(inicio);
       sprintf(inicio,"DO");
   envia_byte_lcd(0,0xC6);
       putsXLCD(inicio);
       sprintf(inicio,"FUNCIONAMENTO");
   envia_byte_lcd(0,0x91);
       putsXLCD(inicio);
       Delay100ms(2);

if(PORTBbits.RB3 == 1) // config

{

   limpa_lcd();
aux1 = 1;
   interrupcao = 0;
   while(PORTBbits.RB3 == 1);
   }

if(aux1 == 1 )
{

while(1)

{

           sprintf(inicio,"HORA DE LIGAR");
       envia_byte_lcd(0,0x80);
       putsXLCD(inicio);
           sprintf(inicio,"HORA DE DESLIGAR");
       envia_byte_lcd(0,0xC0);
           putsXLCD(inicio);
           sprintf(inicio,"SENTIDO");
       envia_byte_lcd(0,0x90);
       putsXLCD(inicio);
           sprintf(inicio,"CONTROLE OFF");
       envia_byte_lcd(0,0xD0);
       putsXLCD(inicio);
           Delay100ms(2);

if(auxiliar == 0)

           {
                   sprintf(inicio," ");
               envia_byte_lcd(0,0x80);
               putsXLCD(inicio);
                   Delay100ms(2);

}

if(auxiliar == 1)

{

                   sprintf(inicio," ");
               envia_byte_lcd(0,0xC0);
                   putsXLCD(inicio);
                   Delay100ms(2);

}

if(auxiliar == 2)

{

                   sprintf(inicio," ");
               envia_byte_lcd(0,0x90);
               putsXLCD(inicio);
                   Delay100ms(2);

}

if(auxiliar == 3)

{

                   sprintf(inicio," ");
               envia_byte_lcd(0,0xD0);
               putsXLCD(inicio);
                   Delay100ms(2);

}

if(PORTBbits.RB4 == 1 ) //ACRESCENTA

{

           auxiliar++;
           cont = 0;
           if(auxiliar > 3)
           {
               auxiliar = 3;
           }

while(PORTBbits.RB4 == 1);

}

if(PORTCbits.RC3 == 1 ) // DECRECENTA

{

auxiliar --;
cont = 0;

           if(auxiliar > 3 )
           {
               auxiliar = 0;
           }

while(PORTCbits.RC3 == 1);
}

if(PORTBbits.RB6 == 1) //ENTER

{

switch (auxiliar)
{

case 0: aux3 = 1;
Config_Liga_Desliga();
break;

case 1: Config_Liga_Desliga ();
break;

case 2: Sentido();
break;

case 3: Controle_on_off();
break;

}

limpa_lcd();
while(PORTBbits.RB6 == 1);

}

if(PORTBbits.RB3 == 1 || interrupcao == 1)

       {   aux1 = 2;
           interrupcao = 0;
           limpa_lcd();
           break;
           while(PORTBbits.RB3 == 1);

}

}
if(aux1 == 2)

{

aux1 = 0;
break;

}

void Registradores(void)

{

   TRISB = 0b11111111;
   TRISC = 0b00001000;
   TRISD = 0b00000000;

   ADCON1 = 15;
   CMCON = 7;
   PORTB = 0b00000000;
   PORTC = 0b00000000;
   PORTD = 0b00000000;

set_datetime(9,11,97,23,55,0,0);
inicializa_lcd();

//http://www.jgorasia.com/Files/UBWdemos/Documentation/periph-lib/Timer.htm

//https://class.ee.washington.edu/475/peckol/code/Microchip/microchipExamples/doc/periph-lib/PWM.htm

   OpenTimer2(TIMER_INT_OFF & T2_PS_1_16 );// HABILITA TIMER 2
   OpenPWM1(24); // HABILITA PWM 1 E CONFIGURA O PERÍODO/FREQUÊNCIA
   SetOutputPWM1 (SINGLE_OUT, PWM_MODE_1); // CONFIGURA O TIPO DE SAÍDA E O MODO DO PWM1   SetDCPWM1(10); //VALOR DE TON(%)>>> CONFIGURA TON E TOFF DO PWM >>> TON PEQUENO E TOFF GRANDE
   SetDCPWM1(10); //VALOR DE TON(%)>>> CONFIGURA TON E TOFF DO PWM >>> TON PEQUENO E TOFF GRANDE
   Configura_Interrupcao();

INTCONbits.GIE = 1;

}

void Delay100ms(int del)
{
int z = 0;

for(z=0;z<del;z++)
{

Delay10KTCYx(60);

}
}

void Configura_Relogio(void)

{

if(PORTCbits.RC3 == 1 ) //ACRESCENA

   {
cont = 0;
   alto = 1;
       while(PORTCbits.RC3 == 1 );
   }

if(PORTBbits.RB4 == 1 ) //DECRECENTA

   {
           cont = 0;
         baixo = 1;
       while(PORTBbits.RB4 == 1);
   }

if(PORTBbits.RB6 == 1) //ENTER

   {
   aux2 ++;
           while(PORTBbits.RB6 == 1);

}

void Config_Liga_Desliga (void)

{

limpa_lcd();

while(1)

{
if(aux3 == 1)

{
Escreve_lcd_liga();
}

else
{
Escreve_lcd_desliga();
}

Configura_Relogio();

if(aux2 == 0 )
{

if(baixo == 1)

{
segs --;

if(seg1 >= 1 && segs == 255 )

   {
   seg1 --;
   segs = 9;
   }

if(segs == 255)

   {
   segs = 0;
   seg1--;

}

if(seg1 == 255)

{
seg1 = 0;

}

baixo = 0;
}

if(alto == 1 )

{

segs ++;

if(segs >= 10)

   {
   segs = 0;
   seg1++;
   }

if(seg1 == 6)

{
seg1 = 0;

}
alto = 0;
}

}

if(aux2 == 1)
{

if(baixo == 1)

{
mins --;

if(min1 >= 1 && mins == 255 )

   {
   min1 --;
   mins = 9;
   }

if(mins == 255)

   {
   mins = 0;
   min1--;

}

if(min1 == 255)

{
min1 = 0;

}

baixo = 0;
}

if(alto == 1 )

{

mins ++;

if(mins >= 10)

   {
   mins = 0;
   min1++;
   }

if(min1 == 6)

{
min1 = 0;

}
alto = 0;
}

}

if(aux2 == 2)
{

if(baixo == 1)

{
hora --;

if(hor1 >= 1 && hora == 255)

   {
   hor1 --;
   hora = 9;
   }

if(hora == 255 )

   {
   hora = 0;
   hor1--;

}

if(hor1 == 255)

{
hor1 = 0;

}

baixo = 0;

}

if(alto == 1 )

{

hora ++;

if(hora >= 10)

   {
   hora = 0;
   hor1++;
   }

if(hor1 == 2 && hora == 4 )

   {
   hor1 = 0;
   hora = 0;

}
alto = 0;
}

}

if(aux2 == 3 && aux3 == 1 || aux3 == 1 && interrupcao == 1 )

{
sprintf(Liga_escada,"%u%u:%u%u:%u%u",hor1,hora,min1,mins,seg1,segs);
auxiliar = 0;
interrupcao = 0;
aux2 = 0;
aux3 = 0;
break;

}

if(aux2 == 3 && aux3 == 0 || aux3 == 0 && interrupcao == 1 )

       {
           sprintf(Desliga_escada,"%u%u:%u%u:%u%u",hor1,hora,min1,mins,seg1,segs);
           auxiliar = 0;
interrupcao = 0;
aux2 = 0;
break;

}

void Escreve_lcd_liga(void)

{

sprintf(inicio,"HORA DE LIGAR");
envia_byte_lcd(0,0x81);
putsXLCD(inicio);

sprintf(Liga_escada,"%u%u:%u%u:%u%u",hor1,hora,min1,mins,seg1,segs);
envia_byte_lcd(0,0x94);
putsXLCD(Liga_escada);
Delay100ms(2);

if(aux2 == 0)

{

sprintf(Liga_escada,"%u%u:%u%u: ",hor1,hora,min1,mins);
envia_byte_lcd(0,0x94);
putsXLCD(Liga_escada);
Delay100ms(2);

}

if(aux2 == 1)

{

sprintf(Liga_escada,"%u%u: :%u%u",hor1,hora,seg1,segs);
envia_byte_lcd(0,0x94);
putsXLCD(Liga_escada);
Delay100ms(2);

}

if(aux2 == 2)

{

   sprintf(Liga_escada," :%u%u:%u%u",min1,mins,seg1,segs);
envia_byte_lcd(0,0x94);
    putsXLCD(Liga_escada);
   Delay100ms(2);

}

void Escreve_lcd_desliga(void)

{

sprintf(inicio,"HORA DE DESLIGAR");
envia_byte_lcd(0,0x80);
putsXLCD(inicio);

sprintf(Desliga_escada,"%u%u:%u%u:%u%u",hor1,hora,min1,mins,seg1,segs);
envia_byte_lcd(0,0x94);
putsXLCD(Desliga_escada);
Delay100ms(2);

if(aux2 == 0)

{

sprintf(Desliga_escada,"%u%u:%u%u: ",hor1,hora,min1,mins);
envia_byte_lcd(0,0x94);
putsXLCD(Desliga_escada);
Delay100ms(1);

}

if(aux2 == 1)

{

sprintf(Desliga_escada,"%u%u: :%u%u",hor1,hora,seg1,segs);
envia_byte_lcd(0,0x94);
putsXLCD(Desliga_escada);
Delay100ms(2);

}

if(aux2 == 2)

{

sprintf(Desliga_escada," :%u%u:%u%u",min1,mins,seg1,segs);
envia_byte_lcd(0,0x94);
putsXLCD(Desliga_escada);
Delay100ms(2);

}

void Sentido(void)
{

limpa_lcd();
auxiliar = 0;

while(1)
{

           sprintf(inicio,"SENTIDO:");
       envia_byte_lcd(0,0x84);
       putsXLCD(inicio);

if(PORTCbits.RC3 == 1 ) //ACRESCENTA

   {
           sent = 1;
           cont = 0;
   PORTCbits.RC7 = 1;
           sprintf(inicio,"SUBINDO ");
       envia_byte_lcd(0,0x94);
       putsXLCD(inicio);
       while(PORTCbits.RC3 == 1 );
   }

if(PORTBbits.RB4 == 1 ) //DECRECENTA

   {
           sent = 2;
           cont = 0;
       PORTCbits.RC7 = 0;
           sprintf(inicio,"DESCENDO");
       envia_byte_lcd(0,0x94);
       putsXLCD(inicio);
       while(PORTBbits.RB4 == 1);
   }

if(PORTBbits.RB6 == 1 || interrupcao == 1) //ENTER

{

       auxiliar++;
       interrupcao = 0;
       while(PORTBbits.RB6 == 1);

}

if(auxiliar == 2)

   {
       auxiliar = 0;
    break;
   }

}

void Controle_on_off(void)
{

limpa_lcd();
auxiliar = 0;
while(1)
{

           sprintf(inicio,"CONTROLE:");
       envia_byte_lcd(0,0x83);
       putsXLCD(inicio);

if(PORTCbits.RC3 == 1 ) //ACRESCENTA

   {
           controle = 1;
           cont = 0;
   PORTCbits.RC3 = 1;
           sprintf(inicio,"ON ");
       envia_byte_lcd(0,0x96);
           putsXLCD(inicio);
       while(PORTCbits.RC3 == 1 );
   }

if(PORTBbits.RB4 == 1 ) //DECRECENTA

   {
           controle = 0;
            cont = 0;
       PORTCbits.RC4 = 1;
           sprintf(inicio,"OFF");
       envia_byte_lcd(0,0x96);
       putsXLCD(inicio);
       while(PORTBbits.RB4 == 1);
   }

if(PORTBbits.RB6 == 1 || interrupcao == 1) //ENTER

   {
       interrupcao = 0;
       auxiliar++;
       while(PORTBbits.RB6 == 1);

}

if(auxiliar == 2)

   {
       auxiliar = 0;
    break;

}

void Configura_Interrupcao(void)
{
RCONbits.IPEN=0; // Desabilita prioridade de interrupção

INTCONbits.GIE=0; // Desabilita TODAS as interrupções

INTCONbits.PEIE=1; // Habilita interrupção de periféricos

// Configura interrupção do Timer0 para que ocorra um estouro (overflow)
// a cada 1 segundo
OpenTimer0(T0_16BIT & // Timer0 usando 16 bits
T0_SOURCE_INT & // Fonte de clock interna, o mesmo da CPU
T0_PS_1_256 &
// TCY = 1/(Fosc/4)
// Prescaler = 1:256, T = TCY.256.(65536-46005)
TIMER_INT_ON // Habilita interrupção e inicia a contagem do Timer0
);

WriteTimer0(LOAD_TMR0); // Escreve o valor correspondente ao atraso de um segundo
// nos registradores do Timer0: TMR0L e TMR0H

INTCON2bits.TMR0IP=1; // Seleciona ALTA prioridade para interrupção

INTCONbits.TMR0IE=1;

INTCONbits.TMR0IF=0; // Garantir flag inicial da interrupção em zero.
}

#pragma code TIMER0_interrupt = 0x0008

void TIMER0_int(void)
{
_asm goto TRATA_HIGH_INT _endasm
}

#pragma code
#pragma interrupt TRATA_HIGH_INT

void TRATA_HIGH_INT(void)

{

if(INTCONbits.TMR0IF)//Verifica flag da interrupção
{

   //   sprintf(Horas,"%u:%u:%u",get_hr(),get_min(),get_sec());
   cont ++;
       if(cont == 100)

{

interrupcao = 1;
cont = 0;

}

WriteTimer0(LOAD_TMR0);
INTCONbits.TMR0IF = 0; //Limpa flag da interrupção

}
}

adicionado 2 minutos depois

@Isadora Ferraz essas as bibliotecas que estou usando e o programa principal. Por favor, de uma olhada pra mim.

Eu uso a interrupção para mudar o ciclo ativo do PWM.

.if · 21 de junho de 2017

1ªmente registre-se que nunca usei este mc.

Perdão por não analisar com a profundidade que você merece mas tentei sim por alguns instantes amigo e vi só a superfície. Seguinte...

-você parece usar rotinas prontas e mastigadas pra controlar a o pwm e afins. Isto não é totalmente ruim mas te priva de um controle mais absoluto. Por gentileza, consulte o d.s. e atue diretamente nos registradores, entendendo-os e etc

-não consegui ver onde e como você configura dutty cicle pwm na interrupt. Vi apenas uma variável mudando de estado. Em algum momento escondido ela deve atuar no pwm né?

-informe(-se) o quê , quando, onde, porquê ocorre e o quê achas que devia ocorrer. Ou seja responda-se melhor "não funciona" e "começa a travar"

-se usas o proteus ou mplab tem um recurso bem legal que é o break point que podes parar e ver as variáveis e registros p.ex.

-Va por partes. P.ex. desabilite alguma coisa pra fazer outra e veja que está zoando quem.

-Entenda/domine melhor o pwm deste mc. p.ex. fazendo-o gerar uma onda senoidal com um filtro rc.

-Seu programa-sistema-projeto parece estar muito grande. Apesar de eu não conhecer detalhes, penso que pode ser otimizado em tamanho e eficiência

-etc

E finalmente, desculpe antecipadamente pelo desabafo, se estiveres apenas copiando e colando da net, só pra ficar livre do trabalho e sem querer entender nada, sinto mas teremos alguma dificuldade. Sim... tem pessoas com estas características e claro, não teu caso...

abç

Paulo Estêvão · 21 de junho de 2017

@Isadora Ferraz não precisa se desculpar não kkkk. Eu mesmo que fiz o programa. Uso o MPLAB sim. No programa eu ajusto a hora de ligar e desligar a escada, o sentido e uma ferramenta chamada CONTROLE OFF, cuja função é manter a escada girando sem o controle automático da velocidade.

Eu consigo configurar todas as essas características normalmente, mas quando eu "ligo a escada" o PWM não funciona, ele não varia o ciclo ativo.

Essa é a parte que faz a mudança do ciclo ativo .

Eu estou usando a biblioteca padrão do PIC para PWM, sem bibliotecas externas para ele.

if(sent == 2)

{

           sprintf(inicio,"ESCADA DESCENDO");
       envia_byte_lcd(0,0x81);
       putsXLCD(inicio);

           sprintf(inicio,"HORA DE DESLIGAR");
       envia_byte_lcd(0,0xC0);
           putsXLCD(inicio);

envia_byte_lcd(0,0x94);
putsXLCD(Desliga_escada);

if(PORTBbits.RB1 == 1)// SENSOR INFERIOR DA ESCADA ROLANTE (S2)

{

           OpenTimer2 (TIMER_INT_OFF & T2_PS_1_16 ); // HABILITA TIMER 2
           OpenPWM1(24); // HABILITA PWM 1 E CONFIGURA O PERÍODO/FREQUÊNCIA
           SetOutputPWM1 (SINGLE_OUT, PWM_MODE_1); // CONFIGURA O TIPO DE SAÍDA E O MODO DO PWM1
SetDCPWM1(90); //VALOR DE TON(%)>>> CONFIGURA TON E TOFF DO PWM >>> TON GRANDE E TOFF PEQUENO
interrupcao = 0; // VARIÁVEL QUE GERA AS INTERRUPÇÕES NA PROGRAMAÇÃO
           cont = 0; // VARIÁVELQUE AUXILIA NA GERAÇÃO DAS INTERRUPÇÕES
           PORTCbits.RC0 = 1; //LIGA LED QUE INDICA ESCADA SENDO USADA
           PORTCbits.RC1 = 0; //DESLIGA LED QUE INDICA ESCADA INUTILIZADA
while(PORTBbits.RB1==1);
           }

if(interrupcao == 1) // INTERRUPCA0 == 1 SIGNIFICA QUE S1 FICOU UM TEMPO SEM SER ACIONADO

{

           OpenTimer2(TIMER_INT_OFF & T2_PS_1_16 );// HABILITA TIMER 2
           OpenPWM1(24); // HABILITA PWM 1 E CONFIGURA O PERÍODO/FREQUÊNCIA
           SetOutputPWM1 (SINGLE_OUT, PWM_MODE_1); // CONFIGURA O TIPO DE SAÍDA E O MODO DO PWM1
           SetDCPWM1(10); //VALOR DE TON(%)>>> CONFIGURA TON E TOFF DO PWM >>> TON PEQUENO E TOFF GRANDE
           PORTCbits.RC0 = 0 ; //DESLIGA LED QUE INDICA ESCADA SENDO USADA
           PORTCbits.RC1 = 1; //LIGA LED QUE INDICA ESCADA INUTILIZADA

No caso eu tenho um sensor, quando a pessoa passa por ele o ciclo ativo aumenta e ele zera a variável (cont), responsável por fazer o ciclo ativo diminuir. Essa variável é incrementada na interrupção. Quando ela chega em 100 a variável interrupção recebe 1 e nesse estado o ciclo ativo diminui. Lembrando que a interrupção é feita a cada 0,2s e que toda vez que alguém passar pelo sensor as duas variáveis recebem 0 fazendo que o ciclo ativo continue alto. Desse modo só após um tempo que o sensor ficar inativo que o ciclo ativo irá diminuir.

Espero que tenha entendido a lógica kkk

.if · 21 de junho de 2017

45 minutos atrás, Paulo Estêvão disse:

Eu mesmo que fiz o programa.

Aí sim hein...

Seguinte.. quase entendi... Nada que está em negrito ocorre? RB1 está como entrada? E vai a 1? mesmo? E a variável interrupcao? Por acaso ela não vai a zero e logo em seguida volta a um por sua culpa mesmo? Então...A dica que dou é : coloque break points em cada linha em negrito e veja o que (e se) ocorre nas entranhas do mc naquele momento. Pode ser que o pwm esteja mesmo sendo desligado por forças ocultas algo como alguém está setando bit contra sua vontade. P.ex. você disse que a variável interrupcao recebe 1 a cada 0,2s. Neste caso a cada 02,s isto

if(interrupcao == 1) incorre em SetDCPWM1(10) o que anula o ajuste anterior SetDCPWM1(90)

Mas repito que pra esta façanha hás de suar um pouco a camisa e dar uma olhadela no d.s. na parte pwm em nível de bit. P.ex. (chute) se existe algum que libera o reajuste do dutty cycle...