aphawk

@Boladoloko ,
 
Ligue um resistor de 4K7 entre o +5V e o pino que você vai usar do Arduino.
Nesse mesmo pino, ligue o NO , e o terminal C você liga ao terra ( GND ).
 
Quando atingir o fim de curso, a tensão na entrada vai para 0 ok ?
 
Paulo

@Matthwus
 
Vamos lá : após retificar, seus 40 + 40 do transformador devem virar algo perto de 56 + 56  volts.
 
Cada capacitor terá um máximo de 56 Volts, vamos arredondar para 60 volts.
 
Vamos usar um resistor que suporte 2 Watts , mas por garantia vamos dissipar apenas cerca de 1,5 watts.
 
Lembra da velha fórmula da potência:
 
P = V x V / R  
 
De onde tiramos  R = V x V / P
 
Substituindo :  R = 60 x 60 / 1,5 = 2400 ohms.
 
Use o valor comercial mais próximo, 2200 ohms por 2 Watts.
 
Cada resistor vai dissipar :
 
P = 60 x 60 / 2200 = 1,64 Watt.
 
Paulo

@Pedro1617 ,
 
Olha, qualquer Pic servirá, com pelo menos 16 pinos no total, uns 8K de memória flash e uns 368 de Ram, nem precisa ter ADC e nem USB...
 
Acho que um velho Pic16F877A servirá, mas outros menores podem servir, como o 16F648A, embora tenha apenas 256 bytes de Ram e pode te atrapalhar na programação.
 
Se preferir algo bem mais moderno, um 18F452 vai te atender não só nesse projeto, mas em outros bem mais complicados, e tem recursos de sobra !
Eu usaria um desses.
 
Paulo
 
 

@HelloLuj ,
 
Seu problema não tem nada a ver com o compilador, e sim , entender bem o Assembly dos 8051.
Veja :
 
Compare instruction
The 8051 has an instruction for the compare operation. It has the following syntax:
 
CJNE destination,source,relative address
 
In the 8051, the actions of comparing and jumping are combined into a single instruction called CJNE (compare and jump if not equal). The CJNE instruction compares two operands, and jumps if they are not equal. In addition, it changes the CY flag to indicate if the destination operand is larger or smaller. It is important to notice that the operands themselves remain unchanged. For example, after the execution of the instruction “CJNE A, #67H, NEXT”, register A still has its original value. This instruction compares register A with value 67H and jumps to the target address NEXT only if register A has a value other than 67H.
 
Veja o que acontece nos flags :
 

 
Essa instrução compara e se não for igual pula para o endereço desejado, E seta o flag Carry para você verificar se é maior ( CY=0 )  ou menor (CY=1) , simplesmente testando o Carry numa próxima instrução, ok ?
 
Não entendo nada dessa familia -ara te ajudar mais do que isso...
 
Paulo

@eclipsecg ,
 
Pense bem , meu amigo !
 
Você tem 4 conjuntos com Mosfets servindo de porta analógica, onde todas as saídas podem ser ligadas juntas através de diodos , fazendo uma porta E.
 
Cada comparador irá acionar um dos conjuntos Mosfet, e nesse momento o nivel lógico da entrada vai poder ser mostrado na saída !
 
Paulo

Pen Barcode Scanner 
 
Um antigo leitor de codigo de barras... 
 
Paulo

@Mateusg_souza ,
 
Confira o capacitor de 820pF, pode ser que te deram um de 8,2 nF.
 
Só pode ser erro de componente, ou alguma montagem incorreta.
 
Paulo

@Luís Roberto C. da Silva ,
 
Necessariamente não precisa ser em E, mas esse formato ajuda muito a facilitar a montagem do transformador.
 
Os toroidais são mais eficientes, dispersam menos energia elétrica, mas pela construção do núcleo e a maneira de se enrolar, custam bem mais caro, pelo menos o dobro para pequenas capacidades, e bem mais para as grandes capacidades.
 
Não conheço calculadoras para isto, mas existem alguns tutoriais sobre como fazer o seu próprio transformador, com cálculos
detalhados.
 
Sobre fazer um toroidal em casa, penso que é possîvel, mas achar o núcleo pronto não sei não !!!
 
Paulo

Uma ideia é usar um ACS712 de acordo com a sua corrente máxima.
 
A tensão de saída na ausência de corrente é de 2,5 volts. Mas pode variar um pouquinho com a temperatura ou de um componente para outro, então eu faria o seguinte :
 
Montaria um circuito de duplo detector de janela, com um trimpot de ajuste, assim caso a tensão de saída esteja entre 2,45 e 2,55 ( por exemplo, claro ) teria um sinal na saída, e caso estivesse fora desses valores, não teria sinal.
 
O detetor de janela desse tipo você faz com um LM339.
 
Ou pode fazer tudo com microcontrolador também :
 
 
Paulo

Paulo
 

@Kenny Robert ,
 
Sugiro que você continue usando o carregador que veio com o seu helicóptero, já que a bateria é igual, e continue carregando como o fabricante disse no seu manual.
 
Claro que você também pode comprar um carregador inteligente, e assim poder carregar a bateria totalmente, independente do tempo, pois o  carregador vai te avisar quando estiver totalmente carregada e já vai cortar qualquer carga adicional.
 
Os carregadores de baterias NI-MH não mantém a corrente constante, sendo que ela pode variar bastante perto do final.
 
Se seu carregador realmente consegue fornecer uma corrente de carga de 500mA, acho que o tempo mais adequado seria de umas 2 horas de carga.
 
Mas se ele fornece uma corrente menor, por exemplo 350 mA, então nesse caso 3 horas seria mais adequado.
 
Se a sua bateria durou 3 anos, eu manteria o processo original do fabricante !
 
Paulo
 

GERADOR SÍNCRONO DE FREQUÊNCIAS
 
Um amigo precisou de um pequeno circuito que gerasse com precisão as frequências de 9.600 Hz, 480 Hz, 240 Hz, 120 Hz e 60 Hz, de preferência que esses sinais não apresentassem nenhuma diferença de fases entre eles. E feito com componentes de baixo custo.
 
Ou seja, é uma espécie de contador síncrono, onde todos os sinais comutam exatamente no mesmo nanosegundo, sem nenhuma pequena diferença de tempo entre eles.
 
A maneira tradicional de fazer isso envolve uma interrupção de um Timer, de preferência que possa ser programado para gerar o tempo necessário sem nenhum erro.
 
Reparei que todas essas frequências são múltiplas de 60 Hz. Então, a primeira coisa que me passou pela cabeça  foi programar um Timer para gerar os 9600 Hz, e a partir daqui, contaria os ciclos dessa interrupção para ir gerando as outras frequências, por exemplo a frequência de 480 Hz seria gerada a partir de 20 interrupções de 9600 Hz. Ideia simples !
 
Peguei todos os cristais que conheço que são prontamente disponíveis no mercado, acima de 1Mhz, e fui vendo utilizando as fórmulas dos Timers, e cheguei a uma conclusão chata : nenhum deles permite gerar os 9600 Hz precisamente !
 
Sei que existem alguns cristais que permitem, mas quase sempre não se acha eles fácil no mercado. Teria de usar um dos cristais mais comuns.
 
Me lembrei que num projeto anterior, publicado aqui neste tópico mesmo, eu criei um gerador de frequências que utilizava dois Timers, sendo um no modo Counter , e outro como Timer mesmo, e assim conseguia gerar quase qualquer frequência.
 
Assim, após algumas contas, cheguei a um cristal de 12.288 Mhz, facilmente encontrável no mercado, e que me permite chegar aos 9.600 Hz, pois 12.288 Mhz dividido por 9600 resulta em 1280, que pode ser decomposto em duas multiplicações de várias maneiras. A utilizada foi 4 x 320 .
 
Assim, resolvi encadear a saída do Timer2 na entrada do Timer0, sendo que este ultimo funcionando como Counter.
 
Finalmente, a saída do Timer0 liguei diretamente na entrada INT0 , gerando uma interrupção a toda borda de subida.
 
Pronto, consegui gerar precisamente a interrupção 9600 vezes por segundo, de forma muito precisa, totalmente por hardware. Assim não tenho nenhum possível JITTER nesse período de interrupção.
 
Quando comecei a pensar no programa, percebi que uma maneira simples é inverter os bits da porta de saída , que escolhi como sendo o PORTC, usando a instrução Toggle, mas se isso fosse feito ao longo da rotina de interrupção, sempre existiria um pequeno delay de alguns nanosegundos entre a comutação de um sinal no início da rotina de interrupção e um outro sinal ao final da rotina.
 
Então, tive outra ideia simples :
 
Assim que começa a rotina de interrupção, a primeira coisa que faço é escrever o conteúdo de uma variável na porta de saída PORTC.
 
A seguir, vou fazendo a contagem das interrupções, e conforme for atingido o momento de comutar alguma das saídas, eu faço o Toggle no bit correspondente da variável !
 
Faço o mesmo procedimento para os 5 sinais envolvidos, e saio da rotina de interrupção.
 
Assim, quando houver uma nova interrupção, o conteúdo dessa variável é escrito no port de saída, fazendo com que todos os 5 sinais sejam atualizados no mesmo instante !
 
Ao testar o programa, o que eu obtive era exatamente A METADE da frequência que eu pensei obter, e então percebi que havia me esquecído que ocorrem duas transições no pino INT0 mas apenas uma gera interrupção ... então tive de gerar 19200 Hz em vez de 9600, para que os procedimentos de Toggle funcionassem como eu queria.
 
Então, simplesmente programei o Timer0 para contar a metade dos pulsos, e pronto, consegui gerar todas as frequências de maneira síncrona, sem nenhum JITTER entre elas.
 
Segue o programa, bem simples, que ocupa 1% da memória do Atmega328 :
 
$regfile = "m328pdef.dat" $crystal = 12288000 $hwstack = 90 $swstack = 90 $framesize = 120 ' Vamos criar contadores para cada frequencia a ser gerada Dim X480 As Byte Dim X240 As Byte Dim X120 As Byte Dim X60 As Byte ' Agora, uma variavel para manipularmos os seus bits e criarmos ' as formas de onda desejadas Dim Saida As Byte ' Valor inicial dela será zero Saida = 0 Config Clockdiv = 1 ' Vamos tornar esses 5 pinos do PortC como SAIDA Ddrc.0 = 1 Ddrc.1 = 1 Ddrc.2 = 1 Ddrc.3 = 1 Ddrc.4 = 1 ' Esperamos um pouquinho ... Waitms 10 ' E ja colocamos 0 nos pinos de saida Portc = 0 ' Agora, configurar os dois Timer para gerarmos as frequencias necessarias Config Timer2 = Timer , Prescale = 1 , Compare A = Toggle , Clear Timer = 1 Config Timer0 = Counter , Edge = Falling , Compare A = Toggle , Clear Timer = 1 Stop Timer0 Stop Timer2 Ocr2a = 1 Ocr0a = 79 ' PRONTO, AGORA ESTAMOS GERANDO 19200 HZ SUPER PRECISOS ' E agora vamos configurar para que ocorra uma interrupcao ' na subida do pulso de clock de 19200 Hertz Config Int0 = Rising ' E vamos chamar nossa rotina que vaigerar as formas de onda ! On Int0 Faz_onda Enable Int0 Enable Interrupts Start Timer2 Start Timer0 Fica_aqui: ' loop infinito sem fazer nada Goto Fica_aqui Stop ' SUB-ROTINA DE INTERRUPÇÃO ' 'Gera todas as frequências sem nenhum jitter Faz_onda: ' De cara, colocamos o conteudo da variavel nas saidas Portc = Saida ' E incrementamos todos os contadores Incr X480 Incr X240 Incr X120 Incr X60 ' Aqui geramos a saida de 9600 Toggle Saida.0 ' Agora testamos cada contador para ver se atingiu o valor ' necessario para gerar a frequencia desejada ' e se atingiu, então zeramos o contador ' e invertemos o bit correspondente na variavel If X480 = 20 Then Toggle Saida.1 X480 = 0 End If If X240 = 40 Then Toggle Saida.2 X240 = 0 End If If X120 = 80 Then Toggle Saida.3 X120 = 0 End If If X60 = 160 Then Toggle Saida.4 X60 = 0 End If ' Pronto, fizemos tudo ! Return End  
o Esquema de uso é este aqui :
 

 
Paulo

@Vitor Prado ,
 
Se você não tem experiência com isso, é melhor aprender sobre comunicação serial simples :
 
http://arduinobasics.blogspot.com.br/2012/07/arduino-basics-simple-arduino-serial.html
 
Paulo

@Micilini ,
 
Bom, vou tentar te passar uma ideia mais genérica primeiro.
 
Você está habituado a programar para um computador. E o que define um computador hoje ?
- uso de um microprocessador potente (acima de 1 Ghz de clock, e vários núcleos de processamento)
- grande capacidade de memória ( gigabytes de Ram.... ) podendo ser usada tanto para programas como para dados.
- Não precisa receber ou transmitir informações de outros hardwares além do que pode ser usado na Internet.
 
Um Raspberry Pi se encaixa na definicão de um pequeno computador, pois embora o processador não seja tão potente, ele é bem mais potente do que um microcontrolador, tendo até saida de vídeo HDMI !!!!
 
Agora, o que é um microcontrolador ?
 
- baseado em um microprocessador de baixa velocidade (geralmente abaixo de 100 Mhz) com apenas um núcleo de processamento.
- um conjunto de eletrônica interna capaz de realizar diversas operações de I/O diferentes, que permite ser configurado de várias maneiras conforme a nossa necessidade
- possui poucos pinos se comparado a um microprocessador ( por exemplo 40 pinos, enquanto um microprocessador moderno tem várias centenas de pinos ), os quais podem ser configurados com várias funções diferentes conforme a necessidade
- Pouca memória Ram ( quase sempre abaixo de 2K ), e pouca capacidade de memória de programa ( raramente acima de 64K ).
- Baixo consumo de energia, para poder ser alimentado com baterias ou pilhas.
- Não precisa de saída de vídeo.
 
Então, acho que agora posso te responder melhor....
 
Um Arduíno é uma plataforma de desenvolvimento, baseada em microcontroladores da Atmel. O mais famoso é o Arduíno Uno. Roda a 16 Mhz. Tem capacidade para programas de até 32Kbytes, e a memória Ram é de cerca de 2Kbytes.
 
Como programador de desktop, voce deve ter programas compilados cujo executável muitas vezes passam de 10 Mbytes.... 
 
Com os microcontroladores, terá de fazer programas mais de 100 vezes menores, e para isso utilizamos linguagens mais simples, como o C ou o Assembler. É um desafio enorme fazer programas sofisticados com tão pouca memória !
 
Eu, por exemplo, uso o hardware do Arduíno Uno, mas não uso a IDE do Arduíno, eu programo em Basic e misturo Assembler quando preciso de tempos muito críticos.
 
Não considero um Arduíno lento, mas claro que não daria para fazer um jogo sofisticado que gerasse vídeo também com ele. 
 
Mas já conseguiram simular dois antigos computadores com ele : um Sinclair ZX81, e um Apple II !!!!!
 
Repare que um Arduíno pode controlar um Hexacóptero , e manter ele no ar sem nenhuma interferência humana !!!!!  
 
Portanto, não pode ser considerado "lento" ....
 
Agora, tudo depende de o quê que você quer fazer.... 
 
Paulo
 
 

@Pheldman ,
 
Ok, segue aqui o circuito, junto com o arquivo da simulação no Proteus 8.
 
O botão do lado esquerdo simula o sinal que deve acionar o seu contator.
Do lado direito, temos duas saídas, a primeira indica que ocorreu o GND do contator, a segunda indica que o contato auxiliar fechou o circuito também.
 
Paulo

contator.pdsprj

@ViniciusKruz ,
 
Olhando a resposta parece que está tudo certinho....
 
Eu me refiro a um programa chamado I2C Scanner, ele pesquisa todos os endereços até obter uma resposta.
 
Como uso o Basic, vou te passar um link de um programa que funciona direitinho no Arduino :
 
http://playground.arduino.cc/Main/I2cScanner
 
Implemente ele em seu compilador, e faça o teste em seu CI. Se não tiver resposta, provavelmente o CI está defeituoso.
 
Paulo

@ViniciusKruz ,
 
Você pode pegar uma biblioteca que já faça a comunicação I2C de maneira genérica, acho que é bem mais fácil do que você ficar tentando simular todo o protocolo I2C com Ack / Nak .... Depois é só enviar a sequencia correta de valores !
 
Paulo
 
 

Hoje de tarde tava sem fazer nada, e me veio a ideia de fazer um VU como esse que você quer, com 20 Leds para cada canal, e com Peak Hold, o efeito é igual ao que voce postou. Utilizei também uma escala logarítmica.
 
Usei um Atmega328, mas pode usar um Arduíno Uno da mesma maneira....
 
Não montei o circuito, mas pelo que vi na simulação do Proteus deve funcionar direitinho. Simulei por mais de duas horas ... é um saco simular quando se tem displays multiplexados....
 
Segue o circuito, claro que você pode adaptar ao Arduíno se quiser  e o fonte em Bascom. Fiz todo o processo dentro de uma única interrupção do Timer. Ah, segue o programa também ....
 
$regfile = "m328pdef.dat" $crystal = 16000000 $hwstack = 40 $swstack = 40 $framesize = 40 Dim Canal_e As Word Dim Canal_d As Word Dim Vmax_e As Byte Dim Vmax_d As Byte Dim Old_vmax_e As Byte Dim Old_vmax_d As Byte Dim Saida1 As Byte Dim Saida2 As Byte Dim Saida3 As Byte Dim Saida4 As Byte Dim Saida5 As Byte Dim Saida6 As Byte Dim Mask1 As Byte Dim Mask2 As Byte Dim Mask3 As Byte Dim Mask4 As Byte Dim Mask5 As Byte Dim Mask6 As Byte Dim New_mask1 As Byte Dim New_mask2 As Byte Dim New_mask3 As Byte Dim New_mask4 As Byte Dim New_mask5 As Byte Dim New_mask6 As Byte Dim Contador_d As Byte Dim Contador_e As Byte Dim Contador1_e As Byte Dim Contador1_d As Byte Dim Disp_index As Byte Dim Temp1 As Byte Config Portd = Output Config Portb.0 = Output Config Portb.1 = Output Config Portb.2 = Output Config Portb.3 = Output Config Portb.4 = Output Config Portb.5 = Output Config Timer0 = Timer , Prescale = 1024 Timer1 = 170 ' vamos gerar uma interrupção a cada 5,6 milissegundo ' que corresponde a uma frequencia de Multiplex de 181,68 Hertz ' ou seja, cada display vai acender 30 vezes por segundo ! On Timer0 Timer0_sub Enable Timer0 ' aqui definimos a subrotina que irá ser chamada a cada ' interrupção, e já deixamos o timer0 correr Config Adc = Single , Prescaler = 64 , Reference = Aref Start Adc ' aqui configuramos o conversor a/d para fazer uma leitura ' apenas quando pedirmos. Enable Interrupts Sempre: nop Goto Sempre '------------- ROTINA DE INTERRUPÇÃO ------------------------------------ Timer0_sub: ' Rotina chamada pelo Timer1 a cada 5,6 milisegundos Timer0 = 170 ' recarrega o timer novamente If Disp_index > 5 Then Disp_index = 0 ' vamos ver se já fizemos o ultimo digito, pois então teremos de ' começar pelo primeiro novamente 'Temp1 = Lookup(disp_index , Tabela_pinos) If Disp_index = 0 Then Canal_e = Getadc(0) Canal_e = Getadc(0) Canal_d = Getadc(1) Canal_d = Getadc(1) Mask1 = 0 Mask2 = 0 Mask3 = 0 Mask4 = 0 Mask5 = 0 Mask6 = 0 If Canal_e = 1023 Then Vmax_e = 20 Mask3 = 8 Saida1 = &B11111111 Saida2 = &B11111111 Saida3 = &B00001111 Goto Sai_if Elseif Canal_e > 971 Then Vmax_e = 19 Mask3 = 4 Saida1 = &B11111111 Saida2 = &B11111111 Saida3 = &B00000111 Goto Sai_if Elseif Canal_e > 920 Then Vmax_e = 18 Mask3 = 2 Saida1 = &B11111111 Saida2 = &B11111111 Saida3 = &B00000011 Goto Sai_if Elseif Canal_e > 869 Then Vmax_e = 17 Mask3 = 1 Saida1 = &B11111111 Saida2 = &B11111111 Saida3 = &B00000001 Goto Sai_if Elseif Canal_e > 817 Then Vmax_e = 16 Mask2 = 128 Saida1 = &B11111111 Saida2 = &B11111111 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 766 Then Vmax_e = 15 Mask2 = 64 Saida1 = &B11111111 Saida2 = &B01111111 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 715 Then Vmax_e = 14 Mask2 = 32 Saida1 = &B11111111 Saida2 = &B00111111 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 664 Then Vmax_e = 13 Mask2 = 16 Saida1 = &B11111111 Saida2 = &B00011111 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 613 Then Vmax_e = 12 Mask2 = 8 Saida1 = &B11111111 Saida2 = &B00001111 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 562 Then Vmax_e = 11 Mask2 = 4 Saida1 = &B11111111 Saida2 = &B00000111 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 511 Then Vmax_e = 10 Mask2 = 2 Saida1 = &B11111111 Saida2 = &B00000011 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 459 Then Vmax_e = 9 Mask2 = 1 Saida1 = &B11111111 Saida2 = &B00000001 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 408 Then Vmax_e = 8 Mask1 = 128 Saida1 = &B11111111 Saida2 = &B00000000 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 357 Then Vmax_e = 7 Mask1 = 64 Saida1 = &B01111111 Saida2 = &B00000000 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 255 Then Vmax_e = 6 Mask1 = 32 Saida1 = &B00111111 Saida2 = &B00000000 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 204 Then Vmax_e = 5 Mask1 = 16 Saida1 = &B00011111 Saida2 = &B00000000 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 152 Then Vmax_e = 4 Mask1 = 8 Saida1 = &B00001111 Saida2 = &B00000000 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 101 Then Vmax_e = 3 Mask1 = 4 Saida1 = &B00000111 Saida2 = &B00000000 Saida3 = &B00000000 Goto Sai_if Elseif Canal_e > 51 Then Vmax_e = 2 Mask1 = 2 Saida1 = &B00000011 Saida2 = &B00000000 Saida3 = &B00000000 Goto Sai_if Else Vmax_e = 1 Mask1 = 1 Saida1 = &B00000001 Saida2 = &B00000000 Saida3 = &B00000000 End If Sai_if: If Canal_d = 1023 Then Vmax_d = 20 Mask6 = 8 Saida4 = &B11111111 Saida5 = &B11111111 Saida6 = &B00001111 Goto Sai_if1 Elseif Canal_d > 971 Then Vmax_d = 19 Mask6 = 4 Saida4 = &B11111111 Saida5 = &B11111111 Saida6 = &B00000111 Goto Sai_if1 Elseif Canal_d > 920 Then Vmax_d = 18 Mask6 = 2 Saida4 = &B11111111 Saida5 = &B11111111 Saida6 = &B00000011 Goto Sai_if1 Elseif Canal_d > 869 Then Vmax_d = 17 Mask6 = 1 Saida4 = &B11111111 Saida5 = &B11111111 Saida6 = &B00000001 Goto Sai_if1 Elseif Canal_d > 817 Then Vmax_d = 16 Mask5 = 128 Saida4 = &B11111111 Saida5 = &B11111111 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 766 Then Vmax_d = 15 Mask5 = 64 Saida4 = &B11111111 Saida5 = &B01111111 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 715 Then Vmax_d = 14 Mask5 = 32 Saida4 = &B11111111 Saida5 = &B00111111 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 664 Then Vmax_d = 13 Mask5 = 16 Saida4 = &B11111111 Saida5 = &B00011111 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 613 Then Vmax_d = 12 Mask5 = 8 Saida4 = &B11111111 Saida5 = &B00001111 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 562 Then Vmax_d = 11 Mask5 = 4 Saida4 = &B11111111 Saida5 = &B00000111 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 511 Then Vmax_d = 10 Mask5 = 2 Saida4 = &B11111111 Saida5 = &B00000011 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 459 Then Vmax_d = 9 Mask5 = 1 Saida4 = &B11111111 Saida5 = &B00000001 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 408 Then Vmax_d = 8 Mask4 = 128 Saida4 = &B11111111 Saida5 = &B00000000 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 357 Then Vmax_d = 7 Mask4 = 64 Saida4 = &B01111111 Saida5 = &B00000000 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 255 Then Vmax_d = 6 Mask4 = 32 Saida4 = &B00111111 Saida5 = &B00000000 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 204 Then Vmax_d = 5 Mask4 = 16 Saida4 = &B00011111 Saida5 = &B00000000 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 152 Then Vmax_d = 4 Mask4 = 8 Saida4 = &B00001111 Saida5 = &B00000000 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 101 Then Vmax_d = 3 Mask4 = 4 Saida4 = &B00000111 Saida5 = &B00000000 Saida6 = &B00000000 Goto Sai_if1 Elseif Canal_d > 51 Then Vmax_d = 2 Mask4 = 2 Saida4 = &B00000011 Saida5 = &B00000000 Saida6 = &B00000000 Goto Sai_if1 Else Vmax_d = 1 Mask4 = 1 Saida4 = &B00000001 Saida5 = &B00000000 Saida6 = &B00000000 End If Sai_if1: End If 'agora, vamos comparar se teve novo máximo If Vmax_e >= Old_vmax_e Then Contador_e = 0 Old_vmax_e = Vmax_e Contador1_e = 0 New_mask1 = Mask1 New_mask2 = Mask2 New_mask3 = Mask3 Else Incr Contador_e If Contador_e > 96 Then ' precisamos fazer o decaimento If Contador1_e = 6 Then Contador1_e = 0 'agora, mudar para o led logo abaixo If New_mask3 > 1 Then Shift New_mask3 , Right , 1 New_mask2 = 0 New_mask1 = 0 Elseif New_mask3 = 1 Then New_mask3 = 0 New_mask2 = 128 New_mask1 = 0 Elseif New_mask2 > 1 Then Shift New_mask2 , Right , 1 New_mask3 = 0 New_mask1 = 0 Elseif New_mask2 = 1 Then New_mask2 = 0 New_mask1 = 128 New_mask3 = 0 Elseif New_mask1 > 1 Then Shift New_mask1 , Right , 1 New_mask3 = 0 New_mask2 = 0 Else New_mask1 = 1 New_mask2 = 0 New_mask3 = 0 End If Decr Old_vmax_e If Old_vmax_e = 0 Then Old_vmax_e = 1 Incr Contador1_e Else Incr Contador1_e End If End If End If 'agora, vamos comparar se teve novo máximo If Vmax_d >= Old_vmax_d Then Contador_d = 0 Old_vmax_d = Vmax_d Contador1_d = 0 New_mask4 = Mask4 New_mask5 = Mask5 New_mask6 = Mask6 Else Incr Contador_d If Contador_d > 96 Then ' precisamos fazer o decaimento If Contador1_d = 6 Then Contador1_d = 0 'agora, mudar para o led logo abaixo If New_mask6 > 1 Then Shift New_mask6 , Right , 1 New_mask5 = 0 New_mask4 = 0 Elseif New_mask6 = 1 Then New_mask6 = 0 New_mask5 = 128 New_mask4 = 0 Elseif New_mask5 > 1 Then Shift New_mask5 , Right , 1 New_mask6 = 0 New_mask4 = 0 Elseif New_mask5 = 1 Then New_mask5 = 0 New_mask4 = 128 New_mask6 = 0 Elseif New_mask4 > 1 Then Shift New_mask4 , Right , 1 New_mask5 = 0 New_mask6 = 0 Else New_mask4 = 1 New_mask5 = 0 New_mask6 = 0 End If Decr Old_vmax_d If Old_vmax_d = 0 Then Old_vmax_d = 1 Incr Contador1_d Else Incr Contador1_d End If End If End If Portb = 0 'Apaga todos os leds Temp1 = Lookup(disp_index , Tabela_pinos) If Disp_index = 0 Then Portd = Saida1 Or New_mask1 Elseif Disp_index = 1 Then Portd = Saida2 Or New_mask2 Elseif Disp_index = 2 Then Portd = Saida3 Or New_mask3 Elseif Disp_index = 3 Then Portd = Saida4 Or New_mask4 Elseif Disp_index = 4 Then Portd = Saida5 Or New_mask5 Elseif Disp_index = 5 Then Portd = Saida6 Or New_mask6 Else nop End If Incr Disp_index If Contador_d = 255 Then Decr Contador_d End If If Contador_e = 255 Then Decr Contador_e End If Portb = Temp1 Return End Tabela_pinos: Data 1 , 2 , 4 , 8 , 16 , 32  
O programa ocupa 4.1 K , e utiliza cerca de 200 bytes de Ram no total, dá para usar um monte de Cis.....
 
Repare que no Proteus os Bargraph de Leds são de 10 Leds, mas eu só uso 8 Leds. Na prática, tem de comprar barras de 8 Leds para quatro dos displays, e barras de 4 Leds para dois displays. Ou utilizar tudo Leds Avulsos...
RN1 é um resistor array de 10K, e RN2 é de 150 ohms. Se quiser pode trocar por resistores individuais.
O Trimpot RV1 de 4,7K ajusta a sensibilidade do conversor A/D.
Utilizei dois diodos de sinal Schottky, mas pode utilizar um 1n914.
 
Agora, a passagem para um Pic é com você, meu amigo !
 
Paulo
 

@MaXwEllDeN,,
Complementando a explicação do colega Moley :
Para que o Tip começe a conduzir, a corrente sobre o resistor de 5 ohms tem de ser de 140 mA, o que daria a queda de tensão de 0,7 volts, certo ?
Portanto, para correntes menores do que esta, quem faz todo o trabalho é o regulador 7812 .
A partir dos 140 mA, quem fornece o restante da corrente é o Tip, e nesse caso o 7812 estará agindo como um diodo Zener, estabilizando a tensão na base do Tip.
O capacitor de 0.33 garante a estabilidade do 7812 contra ruídos, e de quebra temos um efeito interessante, pois esse mesmo capacitor tem o seu efeito estabilizador multiplicado pelo ganho do transistor, "aparecendo" na saída do transistor como um valor bem maior, melhorando a filtragem na saída.
Procure por um circuito regulador simples baseado em transistor e zener na base, e vai perceber que o funcionamento é idêntico !
A finalidade desse circuito é garantir que a corrente sobre o 7812 não seja maior que os 140 mA, o que ajuda bastante na dissipação de calor, e, claro, também permite correntes na carga acima de 1A .
Paulo

@vctrop,
O Rjjj twm razão nisso. Pelo menos esse Pic tem como rodar no Proteus, e para que está iniciando, o Proteus é a melhor ferramenta possível.
Tecnicamente, sem dúvida o Arm7 é superior aos Pics e aos Avrs. Mas isto não significa que voce deve usar eles em qualquer projeto !
voce sempre vai ter projetos que são perfeitos para um Pic, onde usar um Arm seria um custo maior e sem nenhuma necessidade. E também terá projetos que será obrigado a usar um Arm !
No momento, o que importa é seu aprendizado. Olhando isso, eu ficaria no Pic. ( já que um AVR estå fora de questão, claro ! )
Paulo

Me lembrei de algo que é bem importante .....
 
Esse teorema de Nyquist não é mais limitante hoje em dia, desde que se saiba como contorná-lo! Não é simples, e envolve um hardware muito dedicado, mas existe !
 
Desde 1988 surgiram várias técnicas de modulação que permitem um fluxo de dados muito maior do que a máxima largura de banda passante do sinal !
 
Quem se lembra dos modens utilizados em telefonia, recentes até,  que permitiam a comunicação em 56 Kbps , usando um espectro de áudio de apenas 3,5 Khz ?
 
Oras, se pensarmos apenas em Nyquist, se a largura de banda passante é de 3,5 Khz, como conseguimos passar dados numa taxa de 56 Kbits / segundo ???????
 
Na melhor das hipóteses, para recuperar os dados a 56 Kbps do outro lado da linha, teríamos de estar amostrando a uma velocidade de O DOBRO disso, isto é, 112 Ksamples por segundo.
 
Mas como passar isso tudo com uma largura de banda da linha telefônica de apenas 3,5 Khz ??????
 
Surgiram novas técnicas de modulação de sinal, que utilizam multifases na transferência de dados. É como se tivéssemos vários sinais modulantes, e o que nos importa como dado a ser recuperado é a diferença de fase entre esses sinais !
 
Na minha época de formatura, 1983, esse teorema de Nyquist era uma Lei, e até os professores afirmavam que nada poderia ser feito que contrariasse esse teorema, que sempre foi muito utilizado na recosntrução de um sinal. E os modems mais rápidos que existiam eram de 1200 Bps e custavam uma fortuna ! Mas nada como o tempo e a tecnologia para derrubar uma Lei !
 
A técnica que permitiu ultrapassar os 1200 Bps para 2400 e depois evoluindo até 56 Kbps é bem complexa, e isso surgiu bem depois de que me formei na faculdade, então não sei bem como isso tudo funciona. Mas podem achar isso no Google.
 
Fica aqui apenas a título de informação, como um exemplo de que mesmo teoremas imaginados como impossíveis de estarem errados, como o de Nyquist , ou o de Einstem sobre ser impossível de viajar em uma velocidade acima à da velocidade da luz, podem ser derrubados pelo avanço da tecnologia !
 
Paulo

Tá certo, voce ganhou heheheh,  existir, existe.... mas não é para iniciantes, ainda mais gastar US$ 600 pelo modelo mais simples , fora impostos de importação.... Nesse valor, eu prefiro comprar um belo osciloscópio !!!!
 
Eu perguntei qual a família justamente por isso .... gastar o melhor possível no gravador, e sobrar para outros investimentos mais necessários, como um bom multitester digital, uma fonte de alimentação, protoboards, kits básicos de componentes, enfim.....
 
Paulo

@Maninho Steinberg,
 
Sim, isso mesmo, não sei qual o seu projeto, mas um dos modelos mais baratos , poderosos e que se encontra bem fácil aqui é o Atmega328P, o mesmo que é usado no Arduíno. Tem 32K de Flash para programa, 2K de RAM, e 1K de EEprom.
 
O compilador C para ele é gratuíto e você pode baixar o AVR Studio direto do site da ATMEL, mas pode ser uma versão mais simples e antiga, tipo a 4, pois a ultima versão é enorme e cheia de coisa que difícilmente será usado....
 
Ou pode fazer como eu, programar em Basic kkkkk !
 
Paulo

@Kaue Vetorazi,
 
Infelizmente não conheço nada de nada de linguagem C ou ASM para Pics..... prá mim isso tudo é pior que Grego, é Sânscrito kkkkk, nem imagino o que é X-CTU ....
 
Não posso te ajudar nisso, vamos aguardar algum colega experiente nisso para te ajudar.
 
Paulo

@test man*~,
 
Olhe aqui, no início tem as instruções e os ciclos da linha 16F.
 
http://ww1.microchip.com/downloads/en/DeviceDoc/31029a.pdf
 
Não dá para generalizar, tem de fazer as contas mesmo .....
 
A 20 Mhz, o ciclo de máquina é de 200 nanosegundos, voce está correto !
 
 
Paulo