Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.

Lucas Pereira de Souza

Membros Plenos
  • Total de itens

    72
  • Registro em

  • Última visita

  • Qualificações

    0%

Reputação

15

1 Seguidor

Sobre Lucas Pereira de Souza

  • Data de Nascimento 19-09-1992 (25 anos)

Informações gerais

  • Cidade e Estado
    São Paulo
  • Sexo
    Masculino

Meu PC

  • Processador
    FX-8300 3.3GHz @ 4.2GHz
  • Cooler
    COOLER MASTER SEIDON 120V
  • Placa de vídeo
    RX480 SAPHIRE NITRO 4GB
  • Placa-mãe
    Gigabyte ga-78lmt-usb3
  • Memória
    16GB CORSAIR 1600MHz DDR3
  • HDs
    2HDs - 1TB,400GB
  • Gabinete
    SENTEY VULCANO GS6300
  • Fonte
    CORSAIR 500W
  • Mouse
    COUGAR IRON GRAY 400M
  • Teclado
    REDRAGON VARA
  • Headset
    REDRAGON TALOS H601
  • Monitor
    SANSUMG 27
  • Sistema Operacional
    WINDOWS 7
  • Browser
    FIREFOX

Meu Console

  • Modelo
    Super Nintendoo

Outros

  • Interesses
    Eletrônica
  1. O problema e que essa TV também será usada para assistir, se for pegar um de 32 HD caso não fique bom a imagem opto para uma de 42 FULL HD
  2. Na sua opinião, para jogar fica muito ruim uma tela dessa HD ?
  3. Pessoal gostaria de saber a suas opiniões , se uma TV 32 HD e aceitável para jogar no PC, eu ate queria comprar uma FULL HD mais não acha mais no mercado. o modelo e a LG 32LJ500B HD ou Samsung 32J4300 HD. E para jogar no MEU PC e assistir filmes.
  4. No fim consegui fazer a leitura do sinal, utilizei o modo ccp em borda de subida de borda de descida, sendo assim o timer1 armazena o tempo do pulso na interrupção do modulo ccp, veja: void interrupt() { //BORDA DE DESCIDA if(CCP1IF_bit == 1 && CCP1M0_bit == 1 && CCP1M1_bit == 0 && CCP1M2_bit == 1 && CCP1M3_bit == 0) { CCP1IF_bit = 0; // LIMPAR FLAG DE INTERRUPCÃO CCP1IE_bit = 0; // DESABILITAR INTERRUPCÃO CCP1M0_bit = 0; // CCP MODO DE EM BORDA DE DESCIDA CCP1M1_bit = 0; CCP1M2_bit = 1; CCP1M3_bit = 0; CCP1IE_bit = 1; // HABILITAR INTERRUPCÃO TMR1H = 0x00; TMR1L = 0x00; TMR1ON_bit = 1; // LIGAR O TIMER1 } //BORDA DE SUBIDA else if(CCP1IF_bit == 1 && CCP1M0_bit == 0 && CCP1M1_bit == 0 && CCP1M2_bit == 1 && CCP1M3_bit == 0) { CCP1IF_bit = 0; // LIMPAR FLAG DE INTERRUPCÃO TMR1ON_bit = 0; // TIMER1 DESLIGADO CCP1IE_bit = 0; // DESABILITA INTERRUPCÃO CCP1M0_bit = 1; // CCP MODO DE EM BORDA DE SUBIDA CCP1M1_bit = 0; CCP1M2_bit = 1; CCP1M3_bit = 0; CCP1IE_bit = 1; // HABILITA INTERRUPCÃO tempo_H = CCPR1H; tempo_L = CCPR1L; }
  5. Eu fiz o que você falou, me parece que ele fica preso no while(sinal_tensao && sinal_corrente == 1), mas e muito esquisito, isso não deveria ocorrer, sendo assim, resolvi fazer o projeto em outro compilador e o erro persistiu, então resolvi ao invés de usar duas entrada no uC, utilizei uma porta and para pegar os dois sinal de entrada e mandar apnes um sinal de saída para eu poder calcular o tempo sem a necessidade do uC comparar dois sinal, e o mesmo problema persistiu, sendo assim, só Jesus na causa. Veja o código feito no mikroC e a nova implementação . // LCD module connections sbit LCD_RS at RE0_bit; sbit LCD_EN at RE1_bit; sbit LCD_D4 at RD4_bit; sbit LCD_D5 at RD5_bit; sbit LCD_D6 at RD6_bit; sbit LCD_D7 at RD7_bit; sbit LCD_RS_Direction at TRISE0_bit; sbit LCD_EN_Direction at TRISE1_bit; sbit LCD_D4_Direction at TRISD4_bit; sbit LCD_D5_Direction at TRISD5_bit; sbit LCD_D6_Direction at TRISD6_bit; sbit LCD_D7_Direction at TRISD7_bit; // End LCD module connections #define SINC RA0_bit #define LED_TEST RE2_bit void pic_start(); float timer0_carga(); float tempo; float numero[13]; int i; void main() { pic_start(); Lcd_Out(1,1,"FATOR POTENCIA"); //ESCREVE NO LCD PRIMEIRA LINHA while(1) { while(SINC == 1) { TMR0ON_bit = 1; } tempo = timer0_carga(); FloatToStr(tempo,numero); lcd_out(2,1,numero); } } void pic_start() { TRISD = 0x00; // TODOS PORTD COMO SAIDA Lcd_Init(); // Initialize LCD Lcd_Cmd(_LCD_CLEAR); // Clear display Lcd_Cmd(_LCD_CURSOR_OFF); // Cursor off TRISE2_bit = 0; //TODOS PORTE COMO SAIDA, EXCETO MCLR PARA O RESET RE2_bit = 0; //PORTE EM ZERO TRISA0_bit = 1; //PORT RA0 COMO ENTRADA TRISA1_bit = 1; //PORT RA1 COMO ENTRADA PCFG0_bit = 1; //ALL PORTS DIGITAL PCFG1_bit = 1; //ALL PORTS DIGITAL PCFG2_bit = 1; //ALL PORTS DIGITAL PCFG3_bit = 1; //ALL PORTS DIGITAL GIE_bit = 0; // DESABILITA TODAS INTERRUPCOES MASCARADAS GIEH_bit = 0; // DESABILITA TODAS INTERRUPCOES DE ALTA PRIORIDADE PEIE_bit = 0; // DESABILITA TODAS INTERRUPCOES PERIFERICAS GIEL_bit = 0; // DESABILITA TODAS INTERRUPCOES DE BAIXA PRIORIDADE TMR0IE_bit = 0; // BIT DE OVERFLOW DO TIMER0 DESLIGADO TMR0IF_bit = 0; // BIT TIMER0 LIMPO TMR0ON_bit = 0; // TIMER0 DESLIGADO T08BIT_bit = 1; // TIMER0 CONFIGURADO COMO 8BIT T0CS_bit = 0; // TIMER0 CONFIGURADO COMO TEMPORIZADOR PSA_bit = 0; // O PRESCALER FOI ASSOCIADO AO TIMER0 T0PS0_bit = 1; // PRESCALER DO TIMER 1:256 T0PS1_bit = 1; T0PS2_bit = 1; TMR0L = 0x00; // CARGA DO TIMER0 EM ZERO } float timer0_carga() { float result; TMR0ON_bit = 0; // TIMER0 DESLIGADO TMR0IF_bit = 0; result = TMR0L; result = result*13.1072; result = result/256.0; TMR0L = 0x00; return result; }
  6. Eu tentei usar essa lógica veja: while(!SINAL_CORRENTE) { T0CONbits.TMR0ON = 1; } while(!SINAL_TENSAO) { T0CONbits.TMR0ON = 0; } w = timer0_carga(); // DESLIGA O TIMER0 E FAZ A CONTA PARA MS Mesmo assim não deu certo, ele ate mostra no lcd o tempo, ma não importa a defasagem dos pulso o tempo sempre e o mesmo, e em relação ao prescaler, eu já tinha usado veja lá na prototipo timer0_config(); veja: t0conbits.t0ps0 = 1; // prescaler do timer 1:256 t0conbits.t0ps1 = 1; t0conbits.t0ps2 = 1; No meu caso, meu timer0 faz contagem ate 13ms já que o pulso que quero medir e no máximo 8.3ms já e o suficiente.
  7. #include #include #include #include #include /*observacão: o port do lcd e configurado no portd como os pinos de dados,(d4 a d7 no pino d4 a d7 do uc, e os pinos de comando esta localizado porte, rs no port re0 e pino en no port re1 */ /*escreve segunda linha comando_lcd(0xc0);, escreve primeira linha linha comando_lcd(0x80); printf("lucas %f",v); recebe tipo de variavel e imprime no lcd*/ //%u valor inteiro // pic18f4550 configuration bit settings // config1l #pragma config plldiv = 1 // pll prescaler selection bits (no prescale (4 mhz oscillator input drives pll directly)) // config1h #pragma config fosc = hs // oscillator selection bits (hs oscillator (hs)) // config2l #pragma config pwrt = on // power-up timer enable bit (pwrt enabled) // config2h #pragma config wdt = off // watchdog timer enable bit (wdt disabled (control is placed on the swdten bit)) // config3h #pragma config pbaden = off // portb a/d enable bit (portb pins are configured as analog input channels on reset) #pragma config mclre = on // mclr pin enable bit (mclr pin enabled; re3 input pin disabled) // config4l #pragma config lvp = off // single-supply icsp enable bit (single-supply icsp enabled) // config6h #pragma config wrtc = off // configuration register write protection bit (configuration registers (300000-3000ffh) are not write-protected) #pragma config wrtb = off // boot block write protection bit (boot block (000000-0007ffh) is not write-protected) #pragma config wrtd = off // data eeprom write protection bit (data eeprom is not write-protected) //defiines #define _xtal_freq 20000000 #define led_test portebits.re2 #define sinal_tensao portabits.ra1 #define sinal_corrente portabits.ra1 //end define //prototipos funcoes void pic_start(); void lcd_iniciar(); //prototipo para iniciar lcd void comando_lcd(char comandos); //prototipo para comando do lcd void lcd_dado(char dados); //prototipo para dados do lcd void putch(char escrita); //prototipo padrão c para criar mais de um caracter no lcd void timer0_config(); float timer0_carga(); //end prot void interrupt my_isr_high(void) // interrupção de alta prioridade { } void interrupt low_priority my_isr_low(void) // interrupção de baixa prioridade { } void main() { pic_start(); // inicia config do pic lcd_iniciar(); // inicia lcd timer0_config(); // inicia config do timer0 float x = 0; // variavel global printf("fator potencia:"); //escreve no lcd while(1) { while(sinal_tensao && sinal_corrente == 1) { t0conbits.tmr0on = 1; // timer0 ligado } x = timer0_carga(); // desliga o timer0 e faz a conta para ms comando_lcd(0xc0); printf("%fms",x); } } void lcd_iniciar() { /////////////////////////////////////////////////////////////////////////// //config inicial trisd = 0x00; //todos portd como saida /////////////////////////////////////////////////////////////////////////// //inicializacão __delay_ms(15); //aguarda 15ms para inicar o lcd comando_lcd(0x30); __delay_ms(5); //aguarda 5ms comando_lcd(0x30); __delay_us(100); //aguarda 100us comando_lcd(0x30); __delay_us(40); //aguarda 40us comando_lcd(0x30); __delay_ms(5); //aguarda 5ms comando_lcd(0x30); __delay_us(100); //aguarda 100us comando_lcd(0x30); __delay_us(40); //aguarda 40us comando_lcd(0x30); __delay_ms(5); //aguarda 5ms comando_lcd(0x30); __delay_us(100); //aguarda 100us comando_lcd(0x30); __delay_us(40); //aguarda 40us //modo de configuração em 4bits comando_lcd(0x02); //iniciliza em modo 4bits __delay_us(40); //aguarda 40us comando_lcd(0x28); //iniciliza em modo 4bits duas linhas __delay_us(40); //aguarda 40us comando_lcd(0x01); //limpa o lcd __delay_ms(2); //aguarda 2ms comando_lcd(0x0c); //liga o lcd sem o cursor __delay_us(40); //aguarda 40us comando_lcd(0x06); //deslocamento para direita __delay_us(40); //aguarda 40us /////////////////////////////////////////////////////////////////////////// } void comando_lcd(char comandos) { portebits.re0 = 0; //habilita lcd para comando, pino rs __delay_us(100); //aguarda 100us portd = (comandos & 0b11110000); //portd envia o comando para lcd, nible mais significativo portebits.re1 = 1; //habilita pino enable portebits.re1 = 0; //desabilita pino enable __delay_us(100); //aguarda 100us portd = (comandos
  8. Tudo bem pessoal, atualmente estou trabalhando em um projetinho, onde você pode calcular o tempo de defasagem de dois sinal, eu implementei o timer0 como um temporizador para armazenar um tempo de um determinado evento, exemplo, quando o pino ra1 e ra2 do pic ficar em 1 o timer0 dispara e a contagem do evento ocorre em mili segundos, e quando um desses pulso sair dessa condição eu saberei o tempo de defasagem, sendo assim, eu posso calcular o ângulo entre a corrente e a tensão por exemplo, inclusive eu fiz a conta na mão e dava certo, sendo assim, para confirmar se o timer0 que configurei estava certo eu fiz o seguinte teste: código para provar que o timer0 zero estava funcionando corretamente. t0conbits.tmr0on = 1; // timer0 ligado __delay_ms(5); // delay para confirmar se o timer esta correto x = timer0_carga(); // rotina de armazenamento de tempo comando_lcd(0xc0); // escrever na segunda linha do lcd printf("%f ms",x); // escrever a variavel x ate ai tudo bem, consegui realizar esse procedimento, depois desse processo eu fiz a seguinte implementação, eu resolvi medir os dois sinal que entra no pic e contar esses pulso de entrada, que no caso seria dois pulso defasados em 30 graus, veja: nesse caso seria aproximadamente 15.20 - 8 = 7,2ms, ate ai tudo bem então resolvi colocar isso em pratica, eu implementei a seguinte lógica. while(sinal_tensao && sinal_corrente == 1) { t0conbits.tmr0on = 1; // timer0 ligado } x = timer0_carga(); // desliga o timer0 e faz a conta para ms comando_lcd(0xc0); printf("%fms",x); e para minha surpresa o microcontrolador não fez a contagem correta, e isso que me preocupa. veja: agora vou postar o código completo para vocês analisarem, desculpe algumas palavras não ter acento, meu teclado e padrão inglês . #include #include #include #include #include /*observacão: o port do lcd e configurado no portd como os pinos de dados,(d4 a d7 no pino d4 a d7 do uc, e os pinos de comando esta localizado porte, rs no port re0 e pino en no port re1 */ /*escreve segunda linha comando_lcd(0xc0);, escreve primeira linha linha comando_lcd(0x80); printf("lucas %f",v); recebe tipo de variavel e imprime no lcd*/ //%u valor inteiro // pic18f4550 configuration bit settings // config1l #pragma config plldiv = 1 // pll prescaler selection bits (no prescale (4 mhz oscillator input drives pll directly)) // config1h #pragma config fosc = hs // oscillator selection bits (hs oscillator (hs)) // config2l #pragma config pwrt = on // power-up timer enable bit (pwrt enabled) // config2h #pragma config wdt = off // watchdog timer enable bit (wdt disabled (control is placed on the swdten bit)) // config3h #pragma config pbaden = off // portb a/d enable bit (portb<4:0> pins are configured as analog input channels on reset) #pragma config mclre = on // mclr pin enable bit (mclr pin enabled; re3 input pin disabled) // config4l #pragma config lvp = off // single-supply icsp enable bit (single-supply icsp enabled) // config6h #pragma config wrtc = off // configuration register write protection bit (configuration registers (300000-3000ffh) are not write-protected) #pragma config wrtb = off // boot block write protection bit (boot block (000000-0007ffh) is not write-protected) #pragma config wrtd = off // data eeprom write protection bit (data eeprom is not write-protected) //defiines #define _xtal_freq 20000000 #define led_test portebits.re2 #define sinal_tensao portabits.ra1 #define sinal_corrente portabits.ra1 //end define //prototipos funcoes void pic_start(); void lcd_iniciar(); //prototipo para iniciar lcd void comando_lcd(char comandos); //prototipo para comando do lcd void lcd_dado(char dados); //prototipo para dados do lcd void putch(char escrita); //prototipo padrão c para criar mais de um caracter no lcd void timer0_config(); float timer0_carga(); //end prot void interrupt my_isr_high(void) // interrupção de alta prioridade { } void interrupt low_priority my_isr_low(void) // interrupção de baixa prioridade { } void main() { pic_start(); // inicia config do pic lcd_iniciar(); // inicia lcd timer0_config(); // inicia config do timer0 float x = 0; // variavel global printf("fator potencia:"); //escreve no lcd while(1) { while(sinal_tensao && sinal_corrente == 1) { t0conbits.tmr0on = 1; // timer0 ligado } x = timer0_carga(); // desliga o timer0 e faz a conta para ms comando_lcd(0xc0); printf("%fms",x); } } void lcd_iniciar() { /////////////////////////////////////////////////////////////////////////// //config inicial trisd = 0x00; //todos portd como saida /////////////////////////////////////////////////////////////////////////// //inicializacão __delay_ms(15); //aguarda 15ms para inicar o lcd comando_lcd(0x30); __delay_ms(5); //aguarda 5ms comando_lcd(0x30); __delay_us(100); //aguarda 100us comando_lcd(0x30); __delay_us(40); //aguarda 40us comando_lcd(0x30); __delay_ms(5); //aguarda 5ms comando_lcd(0x30); __delay_us(100); //aguarda 100us comando_lcd(0x30); __delay_us(40); //aguarda 40us comando_lcd(0x30); __delay_ms(5); //aguarda 5ms comando_lcd(0x30); __delay_us(100); //aguarda 100us comando_lcd(0x30); __delay_us(40); //aguarda 40us //modo de configuração em 4bits comando_lcd(0x02); //iniciliza em modo 4bits __delay_us(40); //aguarda 40us comando_lcd(0x28); //iniciliza em modo 4bits duas linhas __delay_us(40); //aguarda 40us comando_lcd(0x01); //limpa o lcd __delay_ms(2); //aguarda 2ms comando_lcd(0x0c); //liga o lcd sem o cursor __delay_us(40); //aguarda 40us comando_lcd(0x06); //deslocamento para direita __delay_us(40); //aguarda 40us /////////////////////////////////////////////////////////////////////////// } void comando_lcd(char comandos) { portebits.re0 = 0; //habilita lcd para comando, pino rs __delay_us(100); //aguarda 100us portd = (comandos & 0b11110000); //portd envia o comando para lcd, nible mais significativo portebits.re1 = 1; //habilita pino enable portebits.re1 = 0; //desabilita pino enable __delay_us(100); //aguarda 100us portd = (comandos << 4)& 0b11110000; //portd envia o comando para lcd, nible menos significativo portebits.re1 = 1; //habilita pino enable portebits.re1 = 0; //desabilita pino enable __delay_us(100); //aguarda 100us } void lcd_dado(char dados) { portebits.re0 = 1; //habilita lcd para dados, pino rs __delay_us(100); //aguarda 100us portd = (dados & 0b11110000); //portd envia o caracter para lcd, nible mais significativo portebits.re1 = 1; //habilita pino enable portebits.re1 = 0; //desabilita pino enable __delay_us(100); //aguarda 100us portd = (dados << 4)& 0b11110000; //portd envia o caracter para lcd, nible menos significativo portebits.re1 = 1; //habilita pino enable portebits.re1 = 0; //desabilita pino enable __delay_us(100); //aguarda 100us } void putch(char escrita) { lcd_dado(escrita); } void pic_start() { trisebits.trise0 = 0; //todos porte como saida, exceto mclr para o reset trisebits.trise1 = 0; //todos porte como saida, exceto mclr para o reset trisebits.trise2 = 0; //todos porte como saida, exceto mclr para o reset portebits.re0 = 0; //porte em zero portebits.re1 = 0; //porte em zero portebits.re2 = 0; //porte em zero trisabits.trisa1 = 1; //ra1 como entrada trisabits.trisa2 = 1; //ra2 como entrada portabits.ra1 = 0; //porta em zero portabits.ra1 = 0; //porta em zero adcon1bits.pcfg0 = 1; //configurando todas portas do uc como digitais adcon1bits.pcfg1 = 1; //configurando todas portas do uc como digitais adcon1bits.pcfg2 = 1; //configurando todas portas do uc como digitais adcon1bits.pcfg3 = 1; //configurando todas portas do uc como digitais } void timer0_config() { intconbits.gie = 0; // desabilita todas interrupcoes mascaradas intconbits.gieh = 0; // desabilita todas interrupcoes de alta prioridade intconbits.peie = 0; // desabilita todas interrupcoes perifericas intconbits.giel = 0; // desabilita todas interrupcoes de baixa prioridade intconbits.tmr0ie = 0; // bit de overflow do timer0 desligado intconbits.tmr0if = 0; // bit timer0 limpo //registrador t0con t0conbits.tmr0on = 0; // timer0 desligado t0conbits.t08bit = 1; // timer0 configurado como 8bit t0conbits.t0cs = 0; // timer0 configurado como temporizador t0conbits.psa = 0; // o prescaler foi associado ao timer0 t0conbits.t0ps0 = 1; // prescaler do timer 1:256 t0conbits.t0ps1 = 1; t0conbits.t0ps2 = 1; // carga do timer0 tmr0l = 0x00; } float timer0_carga() { float result; t0conbits.tmr0on = 0; // timer0 desligado intconbits.tmr0if = 0; // limpa flag do timer0 result = tmr0l; // absorve a carga do timer0 na variavel result result = result*13.1072; // conversão do resultado do timer0 para milisegundos para crystal 20mhz 13ms result = result/256.0; // conversão do resultado do timer0 para milisegundos para crystal 20mhz 13ms tmr0l = 0x00; // limpa a carga do timer0 return result; } adicionado 8 minutos depois Para facilitar o entendimento aqui esta o código em PDF. Codigo.pdf
  9. Não muda quase nada, se você conhece a arquitetura não afeta você em nada, eu usava apenas o XC8 e aprendi a usar mikroc em um dia apenas, se você conhece o microcontrolador e fácil usar suas ferramentas. Coloca o seu circuito ai e o código para gente ajudar você.
  10. XC8 e o compilador oficial da Microchip ele e de longe o melhor compilador, trás atualizações com frequências. Essa otimização de memória que você falou ocorre porque você usa a versão gratuita do compilador, eu já usei a versão gratuita e ela não otimiza de propósito, depois eu consegui a versão paga do compilador e a otimização foi ótima. Na minha opinião não existe essa de não vou usar MPLAB X, XC8, C18, MIKROC e CCS ou Assembly para mim e ao contrário, você tem que usar todos os compiladores, conhecer todos ambiente de trabalho para qual microcontrolador você usa, quanto mais ferramentas você usa mais rápido você faz seu projeto, de acordo com a circunstâncias que afetam o mesmo.
  11. Muitas da vezes esses problemas com harmônicas não depende só da sua instalação, mas também a do seu vizinho, talvez a instalação dele esteja produzindo harmônicas na rede.
  12. Eu fiz um encoder a um tempo atrás, da para fazer deu duas maneiras uma e com o CCP do microcontroladoor, a outra e maneira e configurar o timer0 do microcontrolador com contador de pulso externo e converter o valor da contagem para RPM ou RPS, exemplo: rpm = TMR0L; //AMOSTRAGEM DO TIMER0 rpm = rpm*60; //TRANSFORMAÇÃO PARA SEGUNDO rpm = rpm /9; //Aqui e o numero de partes que você contou no caso do exemplo foi 9 lcd_cmd(0b00000001); // Limpa o display lcd_cmd(0xc0); // Posiciona LCD na segunda linha lcd_number(rpm); //ESCREVE VALOR DA CONTAGEM Delay1KTCYx(1); Agora para controlar a velocidade basta implementar rpm em seu PWM.
  13. Como aphawk disse, o correto e você dominar a parte de hardware dos microcontroladores, eu recomendaria que você focasse em estudar eletrônica digital e analógica, para você ter uma base para estudar um hardware de um microcontrolador e suas aplicações. Eu falo isso por experiência própria, mesmo hoje, eu estudando bastante eletrônica analógica e digital dependendo do que eu tenho que projetar com um uC as vezes encontro umas dificuldades. Eu recomendo a você dois fabricantes de microcontroladores, dos quais são os mais conhecido do mercado, ATMEL e MICROCHIP, ambos tem ótimos microcontroladores. No site da Microchip você encontra o IDE para ambos microcontroladores, os dois podem ser programado em assembly e C. A vantagem da placa Arduino e a sua facilidade de programar e montar protótipos, entre tanto, para quem deseja aprender eu não recomendaria ir direto com Arduino, já que você não vai aprender muito, devido as facilidades com o mesmo, porém, se não for por fins de aprendizagem em eletrônica eu recomendaria muito.
  14. Muito obrigado jovem, consegui medir o zero da corrente ficou perfeito deu certinho, sua dica foi preciosa muito obrigado mesmo, a diferença e que eu não usei o acs712 eu utilizei um stc013. O objetivo era fazer um sistema para chavear banco de capacitores, vejam o detector de zero da corrente:
  15. Galera recentemente eu fiz um circuito de detector por zero da tensão, funcionou que e uma maravilha, entre tanto, eu também preciso detectar a passagem por zero da corrente para saber a defasagem da corrente em relação a tensão, gostaria de algumas dicas para desenvolver um circuito.

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações 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

×