Ir ao conteúdo
  • Cadastre-se

Paulo Estêvão

Membro Júnior
  • Posts

    14
  • Cadastrado em

  • Última visita

Reputação

1
  1. Bom dia, gente. Estou com um problema sobre como separar/identificar classes filhas em um vector do tipo pai. Tenho uma classe abstrata chamada Pessoa e outras duas classes, Amigo e Conhecido, que herdam de maneira public Pessoa. A classe Pessoa tem dois atributos, nome e idade, a classe Amigo tem um atributo aniversario e a classe Conhecido tem um atributo chamado e-mail. Eu instancio vários objetos do tipo Amigo e Conhecido e coloco dentro de um vector do tipo Pessoa. Acontece que em determinado ponto tenho que imprimir as datas de aniversário, só obj Amigo possui tal atributo, e também tenho que imprimir os e-mails, só obj Conhecido tem tal atributo. Como eu disse antes todos os obj ficam no meu vector do tipo Pessoa. Eu gostaria de saber se tem alguma forma de eu iterar meu vector e identificar se um objeto é um Amigo ou Conhecido e a partir disso imprimir o que se pede, ou se tem uma solução para que eu consiga chegar no resultado. Eu pensei em no momento da instanciação dos objetos eu colocar cada qual em um vector específico para seu tipo e depois usar um for each em cada vector e imprimir o que se pede, entretanto a proposta é fazer tudo usando esse vector mais geral.
  2. @aphawk Obrigado! @Thiago Miotto Eu acabei mudando para o 2560V-16au. Meu cristal está certo mas o problema continua. Segue foto do gravador, ele possui 6 pinos para a gravação. @aphawk Eu acabei mudando para o 2560V-16 e estou usando um cristal de16 Mhz. Continuo a conseguir gravar o programa mas ele não roda. Ja conferi as ligações da minha placa e estão de acordo com o esquemático. Meu único receio é que eu tenha criado um setup errado para trabalhar com o 2560V-16. Por acaso você teria algum esquemático de uma montagem padrão do 2560V-16 ?
  3. @Thiago Miotto Eu testei o Blink num módulo de Arduino (atmega2560) e deu certo. O circuito na imagem foi impresso numa placa e fiz toda a montagem de acordo com ele, usando um atmega2560V-8AU e outros componentes. Nesse circuito eu consigo gravar os programas mas eles não rodam.
  4. O atmega está com a alimentação certa e já chequei a tensão em seus terminais de alimentação. Não verifiquei o cristal mas se ele estivesse falho não gravaria o programa, certo? Estou usando o compilador da própria ide do arduino genuinio e o programador MegaCore. O programa pisca led é o Blink da própria IDE do arduíno. Já testei ele usando um módulo e deu certo. Mas quando passo pra esse outro não dá.
  5. Boa tarde. Estou com algum problema com o Atmega2560V-8AU e não estou sabendo identificar. Eu montei o circuito abaixo, acredito que a montagem esteja certa. Também consigo realizar a gravação do programa nele. Mas quando energizo nada acontece. Já coloquei alguns pinos em alto para testar se chega tensão e não obtive resposta. Acredito que apesar de eu conseguir gravar o programa por alguma razão ele não está rodando. OBS: No lugar do diodo comum do pino 26 eu coloquei um LED que fica piscando quando eu gravo o bootloader.
  6. Eu entrei num projeto na faculdade e me colocaram na grupo da eletrônica. Nisso me foi pedido para aumentar o isolamento mínimo entre as trilhas da placa do nosso projeto, de 3,8 mils para 8 mils. Estamos mudando porque as empressas de confecção de circuito impresso geralmente trabalham com valores maiores que 6 mils e também para facilitar quando formos soldar os componentes. Nós estamos usando o Altium disigner e gostaria de saber se existe uma forma automática de realizar essa mudança pelo Altium, ou outro programa.
  7. Boa noite. Eu estou com um problema. Tenho que fazer um programa que recebe uma serie de valores e tenho que retornar a maior diferença entre eles. Como os valores são adquiridos no formato "12 22 33 -24 55 66", ou seja, de uma só vez e separados apenas por espaço, estou guardando eles numa string,C++.Minha dúvida é se existe outra maneira de eu guardar esses valores, nesse mesmo formato, em um vetor ou então se existe alguma função na qual eu consigo converter esses caracteres numericos em int.Também aceito sugestôes de maneiras mais faceis de executar o programa rsrsrs.Obrigado!
  8. Boa tarde. Estou realizando um projeto e estou usando um driver A4988 para controlar um motor de passo. Gostaria de saber se alguém tem alguma biblioteca, para o Proteus 8, com esse componente, para eu conseguir gerar o PCB
  9. @Isadora Ferraz OK. Vou seguir seu conselho. Obrigado pela orientação e pela disposição de ajudar!!
  10. @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
  11. 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.
  12. 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!
  13. @AlyssonMachado Teria como você explicar como usa as bibliotecas que você criou/ajustou (I2C e a DS1307). Porque tenho um projeto que necessita das horas,minutos e segundos para ligar e desligar um motor. Ai eu gostaria de saber como uso as funções das bibliotecas para pegar os valores do DS1307 e comparar com outra variável. Até olhei seu exemplo aqui, mas não consegui pegar direito o funcionamento kkk. No mais obrigado!!!
  14. Olá pessoal! Aqui no meu serviço tenho uma tarefa que necessita que eu pegue três tipo diferentes de dados ( os dois primeiros são sequencia de números e o ultimo uma letra) de uma planilha e os coloque um por um nos três campos do site, para eu ter acesso a uma informação. Gostaria de saber se tem como eu criar, e como criar, uma planilha que me permite selecionar os três dados juntos e colar automaticamente nos respectivos campos do site

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...