FAÇA UM CONTADOR DE VOLTAS PARA ENROLAMENTO DE BOBINAS – COM PIC 16F676 /PIC16F628A

1

Muitos hobistas preferem enrolar suas bobinas e transformadores, segundo suas necessidades. Gostaria de controlar melhor o número de voltas? Então veja mais…

A prática do enrolamento não é difícil, mas exige paciência e ter alguns truques práticos para ser bem sucedido. Não entraremos exatamente neste mérito, mas sim, na forma de controlar o número de voltas. Para isto faremos uso do seguinte esquema abaixo:

Ou se preferir, podemos usar a versão abaixo com pic 16f628a:

O que vemos aqui , nada mais é que um simples contador de 4 dígitos (0-9999 voltas) usando display de 7 seguimentos, com ânodo comum. O processo de contagem é feito pelo microcontrolador 16F676 (opcionalmente, com 16f628a), de apenas 14 pinos. Como sensor foi usado um reed switch (interruptor acionado por magnetismo), muito comum em aplicações de alarmes. Geralmente são vendidos aos pares com um imã, ficando fácil a sua obtenção e utilização. Nada impede de usar outro tipo de sensor, como por exemplo, foto-sensor ou mesmo um sensor Hall (daqueles que tem dentro dos pequenos motores de ventiladores de PC). Esta escolha ficará por conta do hobista. Em geral, temos um eixo com manivelas em um extremo, e no outro será preso a forma para enrolamento. Na própria manivela, podemos colar o ‘imã’ e o reed switch poderá ficar preso junto ao mancal de apoio do eixo, em uma posição que fique exposto ao campo magnético do imã e seja acionado por ele uma vez a cada volta (vide o esquema acima).

Abaixo, o formato de reeds comerciais e uma opção com fototransistor. Poderá ser usado os reed pequenos em envolucro de vidro e pequenos imãs retirados de leitores de CD estragados.

USO DO CONTADOR

Após preparar a forma e separar o fio a ser usado, ligue o ‘conta_voltas’, ‘zere’ o mostrador e comece a enrolar. A cada volta na manivela será incrementado o contador, até atingir o número de voltas desejadas. Para nova bobina, repita o processo.

O ARQUIVO ASM

Os displays são multiplexados, sendo apresentados um por vez em um sequência continua, sendo tudo ‘orquestrado’ pela interrupção do timer 0 , a cada 4 milisegundos. O loop principal testa continuamente a entrada do sensor, e quando ocorre uma mudança de estado, irá incrementar o contador CONT0 e CONT1. Em seguida, irá converter o novo valor e colocar nos registradores de apresentação DIG0 A DIG3. A interrupção se encarrega de mostrar estes novos valores. Tudo muito simples!!!
Este contador, obviamente, pode ter outros usos, como por exemplos, controlar uma quantidade de peças que sai de uma linha de produção ( usando sensor de fotosensivel), controle de fluxo de pessoas (uma ‘catraca’ eletrônica) e muitos outros usos.
Obs. Este material foi montado apenas em protoboard, sujeito a bugs ainda não detectados, sendo fornecido o arquivo ASM. Este poderá ser alterado segundo as necessidades do hobista.

Segue o arquivo ASM:

CONTA_VOLTAS_ASM

Segue o arquivo HEX:

CONTA_VOLTAS_HEX

Segue o arquivo ASM para versão com pic 16f628a:

CONTA_VOLTAS_628_ASM

Segue o arquivo HEX para versão com pic 16f628a:

CONTA_VOLTAS_628_HEX

Também, em 15/08/2015 foi postado esta versão com 16f628a, usando catodo comum. Abaixo segue a pasta com os arquivos desta versão:

CONTA_VOLTAS_628_CATODO_FILES

Também, em 16/03/2014, foi feito esta nova versão do contador de voltas, que conta tanto para frente (incrementa a contagem) como para trás (decrementa a contagem). Isto facilita quando temos que retroceder para arrumar o alinhamento do fio em uma bobina que esteja sendo enrolada na forma. Esta versão não foi realizada com 16f676, porque este tem apenas 14 pinos e se necessita de 16 pinos totais.
Utiliza dois fototransistores e 2 leds, um disco opaco, tendo uma janela, preso ao eixo. Quando o disco interrompe a passagem de luz, gera os pulsos de contagem. É importante que a janela do disco permita que os dois fototransistor sejam acionados ao mesmo tempo, uma vez por volta. O funcionamento é bem simples:
Quando giramos para um lado, encontramos primeiro o fototransistor da entrada ‘trig’ (por ex.). A outra entrada ainda está em nivel ‘1’, pois não foi acionado o fototransistor da entrada ‘dir’. Ocorrerá um decremento. Virando ao contrário, acionamos o fototransistor da entrada ‘dir’ e continuando o giro, quando o disco permite iluminar o fototransistor da entrada ‘trig’, ocorrerá um incremento na contagem, pois ‘dir’=0. Assim, a entrada ‘dir’ determinará se será incremento ou decremento. Pode-se usar outros tipos de sensores como reed_switch , sensor ‘hall’ , contatos mecânicos, etc. Foi inserido um delay de 50 ms para fins de ‘debouncing’ em caso de usar chaves mecânicas como sensores.
Segue o esquema:

Segue a pasta com os arquivos em “C” e “Hex”:

CONTADOR_UP_DOWN

Também, em 15/08/2015 foi alterado o arquivo acima para suportar tanto ânodo comum como cátodo comum. Segue a pasta com os arquivos abaixo:

CONTADOR_UP_DOWN_628_CAT

Ainda em 27/05/2016 foi alterado o arquivo em “C” para retirada de bug relacionado a rotação máxima e incremento pós reset. Segue pasta com os novos arquivos, com opção para displays de 7 seguimentos ânodo ou cátodo comum:

CONTA_VOLTAS_628_V2_CAT_FILES

Manuais:
Datasheet PIC16F676
Datasheet PIC16F628a

Preço de PIC

Curiosidades:
O eterno fascínio pelo ouro
O sistema de navegação das tartarugas
Os eficientes e versáteis escudos da Terra
Vespões constrõem com imãs
O universo – cheio de surprêsas
Um trem sem rodas
O que revela a visão do invisível
Monóxido de carbono – o assassino silencioso
O que é Artrite?
Bolor – Amigo ou inimigo?

Outros assuntos:
O que preciso saber sobre trocar mensagens de textos?
Quando um dos cônjuges tem nessidades especiais
Como ser um bom pai
Como lidar com dívidas
Como resolver diferenças no casamento
Como tratar o conjuge com respeito
Como evitar ferir com palavras
Ensine seus filhos bons principios com atividades de colorir
Como posso ter ânimo para exercitar
Como posso controlar meu peso?
Entrevista com um bioquímico

Até o próximo artigo!!!

1

66 comments

    1. 0

      Olá Alberis!
      Eu não entendi o que você quer dizer com ‘passar um nome’! Poderia explicar o que significa?
      Cláudio

        1. 0

          Olá Alberto!
          Estamos usando display de 7 seguimentos. Eles não permitem escrita de caracteres alfabético, exceto alguns como E, P, A, d, H, I, O, L, , S,b, C, U. Não tem como escrever R, k, t, V, X, m, n, z, etc.
          Cláudio

          1. 0

            Olá Alberis!

            Poderia fazer de um jeito simples. Coloque alguns “defines” com os valores das respectivas letras. Depois, na

            inicialização, faça que seja carregado os registradores de apresentação dos dígitos. Apague todos e depois

            coloque a letra ‘A’ no display ‘a0’ e de um delay de 100 Ms ou um pouco mais. Depois carregue a letra “A” no

            segundo display (a1) e a letra “b” no segundo. De mais um delay igual ao primeiro. Continuem fazendo isto até

            entrar todos os caracteres da frase.
            Veja a porção de código abaixo original:

            void main() {
            setup_comparator(NC_NC_NC_NC);
            setup_timer_0(RTCC_INTERNAL|RTCC_DIV_16);
            setup_timer_1(T1_DISABLED);
            porta=0xff;
            portb=0;
            trisb= 0b00000000; //sentido das portas
            trisa= 0b11110000;
            t0ie=1;//habilita interrupções tmr0
            gie=1; //habilita interrupções geral

            dig0=0; //zera contadores inicialmente
            dig1=0;
            dig2=0;
            dig3=0;
            delay_ms(500);

            Mude para:

            #define _a 0b10001000 //para anodo comum. Inverta os dígitos para catodo
            #define _l 0b11000111
            #define _b 0b10000011
            #define _e 0b10000110
            #define _r 0b11001110
            #define _i 0b11111001
            #define _s 0b10010010

            void main() {
            setup_comparator(NC_NC_NC_NC);
            setup_timer_0(RTCC_INTERNAL|RTCC_DIV_16);
            setup_timer_1(T1_DISABLED);
            porta=0xff;
            portb=0;
            trisb= 0b00000000; //sentido das portas
            trisa= 0b11110000;
            t0ie=1;//habilita interrupções tmr0
            gie=1; //habilita interrupções geral

            dig3=0xff;
            dig2=0xff;
            dig1=0xff;
            dig0=0xff;//apaga tudo
            delay_ms(100);
            dig0=_a;
            delay_ms(100);
            dig1=_a;
            dig0=_l;
            delay_ms(100);
            dig2=_a;
            dig1=_l;
            dig0=_b
            delay_ms(100);
            dig3=_a;
            dig2=_l;
            dig1=_b;
            dig0=_e;
            delay_ms(100);
            dig3=_l;
            dig2=_b;
            dig1=_e;
            dig0=_r;
            delay_ms(100);
            dig3=_b;
            dig2=_e;
            dig1=_r;
            dig0=_i;
            delay_ms(100);
            dig3=_e;
            dig2=_r;
            dig1=_i;
            dig0=_s;
            delay_ms(100);
            dig3=_r;
            dig2=_i;
            dig1=_s;
            dig0=0xff;//apaga
            delay_ms(100);
            dig3=_i;
            dig2=_s;
            dig1=0xff;
            dig0=0xff;//apaga
            delay_ms(100);
            dig3=_s;
            dig2=0xff;
            dig1=0xff;
            dig0=0xff;//apaga
            delay_ms(100);
            dig3=0xff;
            dig2=0xff;
            dig1=0xff;
            dig0=0xff;//apaga
            delay_ms(500);

            dig0=0; //zera contadores inicialmente
            dig1=0;
            dig2=0;
            dig3=0;

            Tente fazer isto e veja se é isto que você quer.

            Cláudio

  1. 1

    Bom dia Claudio.

    Fiz a PCB e já montei conforme as fotos e vídeo.
    Eu até tenho alguns displays de 4 dígitos Multiplexados, mas como eles sempre variam muito a pinagem e são difíceis de achar do mesmo modelo, preferi usar Displays comuns de 7 Seg., desses vendidos em qualquer loja de eletrônica.
    No vídeo estou utilizando displays Ânodo Comum e chaves ópticas diversas (uma eu retirei de uma impressora e o outra eu retirei daqueles mouses antigos “de esfera”).
    Em breve eu passo o layout da chave óptica “modelo comercial” pra facilitar pro pessoal.

    Segue Vídeo do teste final:
    https://youtu.be/lDgNcaG_DQs

    Fotos da montagem:
    http://s1121.photobucket.com/user/ricardoams/library/Contador%20Digital%20UP_DOWN%20-%20PIC16F628A

    PCBs, Arquivos Eagle e Raio-X das Duas Versões (Ânodo e Catódo Comum)
    https://drive.google.com/folderview?id=0B5HFSntIQ8OKeWpNYi1qbU1OcFk&usp=sharing

    Forte Abraço

      1. 0

        Bom dia. Que bom que a montagem ficou de agrado.
        Tem um pequeno detalhe (Pequeno mesmo) pra ficar perfeito:

        Notei que ao ligar o circuito, se os sensores estiverem tapados, ele faz uma contagem, sendo necessário que apertemos o botão do reset pra zerar.

        pelo que percebi isso acontece depois dos 500ms do delay. (O circuito liga, passa pouco menos de 1 segundo e faz uma contagem caso os sensores estejam tapados).

        Acredito que isso seja de fácil correção.

        Outra dúvida que eu tenho, é em relação ao brilho dos displays, sei que quando é feita a multiplexação, perdemos um pouco o brilho devido a frequência em que eles piscam para não ser perceptível aos olhos.
        Eu usei resistores 180r pra ganhar um pouquinho mais de brilho, mas mesmo assim ainda achei um pouco fraco. Já vi alguns projetos que os displays são ligados diretamente no PIC, poderia danificar o mesmo?

        1. 1

          Olá Ricardo!
          Experimente logo após o delay de 500 ms colocar o seguinte antes do loop principal:

          while(!trig) zera();//aguarda primeira mudança

          //LOOP PRINCIPAL
          Quanto a não usar resistores, os pic 16f628a tem saída max. de 25 mA por pino para uso direto no led. Somente que a somatória máxima de corrente passando pelo pino gnd não ultrapasse os 300 mA, e a dissipação térmica não ultrapasse os limites delineados no datasheet. Experimente fazer um teste por sua conta e risco. Verifique se não aquece o chip. Talvez dê certo!
          Cláudio

          1. 0

            Olá Ricardo!
            Que bom que funcionou. Depois, por favor, retorne os resultados de seus testes com ligação direta.
            Claudio

          2. 1

            Boa tarde Claudio.
            Fiz o teste, soldei um Jumper em baixo de cada resistor. Realmente melhorou bastante o brilho, mas reparei que os números que tem menos segmentos EX:1,7 acendem um pouco mais forte do que os que tem mais segmentos ex: 8, 9, etc. Mas ficou muito bom. O Pic não esquenta nem um pouco.
            Já fiz a PCB com os dois sensores modelo comercial.
            Todos os arquivos Anodo e Catodo comum já foram atualizados lá no Link do Google Drive que enviei anteriormente.

            Abaixo fotos e vídeo do novo teste:

            https://drive.google.com/file/d/0B5HFSntIQ8OKd0dJZnhBN25CcDA/view?usp=sharing

            https://drive.google.com/file/d/0B5HFSntIQ8OKc1hNX21OM1UyTnM/view?usp=sharing

            https://drive.google.com/file/d/0B5HFSntIQ8OKVk11QWw0aXRxS00/view?usp=sharing

            https://drive.google.com/file/d/0B5HFSntIQ8OKaDllMldMandDZ0U/view?usp=sharing

            https://youtu.be/Bx5no3y_jBk

          3. 0

            Boa noite Claudio.
            To passando pra dar um feedback de um teste que eu fiz.
            Testei na protoboard usando uns displays novos que eu tinha aqui que sobraram de outros projetos e o brilho está perfeito, e olha que usei resistores um pouco maiores (330r). O problema de brilho era com aqueles outros displays mesmo, não tinha haver com os resistores. Segue Foto:

            http://s1121.photobucket.com/user/ricardoams/media/Contador%20Digital%20UP_DOWN%20-%20PIC16F628A/c7fa1cea-3f0b-4b58-b945-0e022a576ab1.jpg.html

          4. 0

            Olá Ricardo!
            Obrigado pelo retorno. Parece que os displays variam muito de luminosidade conforme o modelo e fabricante.
            Cláudio

  2. 0

    Bom dia Claudio. Ótimo projeto, parabéns. Eu montei aqui na protoboard e gostei muito do funcionamento. Gostaria de Tirar uma dúvida e dar uma sugestão: Eu usei no teste uma chave optica de passagem de luz e usei este esquema http://www.scielo.br/img/revistas/rbef/v30n1/a12fig06.gif Liguei diretamente na porta do pic funcionou perfeitamente, porem se eu aumento a rotação para mais de 8 voltas por segundo (Cerca de 500 rpm) ele começa a perder contagem. será que tenho que mudar algo no circuito ou pode ser algum delay no código que pode ser alterado? Agora minha sugestão, seria em caso de queda de energia, ele gravasse na eprom o último valor registrado.

    Olha este video-teste que eu fiz, nesta velocidade ele conta perfeitamente, em outros testes, cheguei a mandar o motor de passo dar 1000 voltas e contou exatamente as 1000 voltas.

    https://youtu.be/Kv2_x9lAWl0

    1. 0

      Olá Ricardo!
      Obrigado pela dica do fotoacoplador. Para mais rpm, tente reduzir o delay de 50 ms para 10 ms. Quanto a salvar na eeprom, creio que talvez seja melhor uma bateria no vcc. Quando acaba energia, o motor ainda dará muitas voltas que não serão registradas. Com a bateria não terá problemas.
      Cláudio

      1. 0

        Obrigado por responder. Qual compilador foi utilizado?
        Eu tentei compilar com o MikroC pro, que eu sempre utilizo pra compilar seus projetos, mas neste aqui não deu certo, deu um milhão de erros.
        Forte abraço.

        1. 0

          Já descobri, usei o Pic C Compiler e deu certo, mudei os delays para 10 e ficou perfeito, mesmo em alta rotação. Não cheguei a ver qual a velocidade máxima até perder a contagem, Mas a velocidade que eu testei já está de acordo com minhas necessidades. muito show. Essa semana eu já desenvolvo a PCB e compartilho aqui para o pessoal. Forte abraço

  3. 0

    Ola´Claudio, Boa Noite, Não Me Lembro se Ao Fazer Esse Comentário Abaixo, Você Já Tinha Colocado Essa Versão UP/DOWN (eu não tinha reparado direito, na pressa de ter de sair) Se Estava Postado, Mas Agora, A Noite Ao Visitar a Página Novamente, é Que Observei Que Tinha Lá Então Um Contador Como Eu Havia Pedido Se Era Possível Você Fazer, Do Jeito Que Realmente Eu Preciso, Fabulosa Essa Sua Criatividade, De Resolver Com Facilidade As Coisas, E Deixar Opção De Escolha, Muito Agradecido, Pois Me Ajudou a Resolver o Meu Problema, Muuuito Agradecido Mesmo. 😀

  4. 0

    Olá Claudio, Eu Poderia Montar Com o CI CD40110,( eu tenho 50 ci’s desse) Este CI Conta UP/DOWN, Para Cada Display, Um CI, Então Teria Que Usar 4, Aí a Montagem Fica Um Pouco Grande, Porém Nesse Caso É Apenas Um CI.

    1. 0

      Olá Bagini!
      Eu não tenho no momento algum contador que conte para cima e alterando um interruptor, para baixo. Quanto ao ci CD40110, poderá usa-lo, sendo um para cada display de 7 seguimento, ligando eles em cascata. Eu não tenho esquema, mas encontrará com facilidade na internet.
      Cláudio

      1. 0

        Bom Dia Claudio Larios, Agradecido Pelo Retorno, Você Tem Sim o Contador Que Mencionei, e é Justamente Este Que Está Na Sua Página (nesta página)Onde Tem a Versão Que Conta Pra Frente e Pra Traz, Com 2 Foto Diodos, Agradeço Pela Atenção, Att

  5. 0

    Olá Claudio, Boa Tarde, Muito Bom Seu Blog, Recheado de Bons Projetos e Ideias, Eu Gostaria de Saber Se Você Tem Um Projeto Parecido Com Este Contador de Voltas, Só Que Com Uma Tecla a Mais, Uma Para Resset, Outra Contagem Para Cima (UP)Como Está Feito e Outra Para Contagem Para Baixo (Down), 3 Teclas. Preciso Fazer Uma Modificação em Um Contador (Onde Conta marcando em sistema analógico) Para Contagem Digital, e Esse Seu Projeto De Contador “Quase Serviu”, Pra Mim. Então gostaria de Saber Se É Possível Você Fazer Essa Mudança, se Não For Incomodo Para VC, Aguardo Uma Resposta, Obrigado

  6. 0

    Gostaria de saber se tem a possibilidade de colocar um rele neste contador para quando atingir um determinado valor ele desarme e desligue a bobinadeira, obrigado!!

    1. 0

      Olá Renato!
      Jeito tem. Mas este método funciona bem se usar baixa rotação ao enrolar. Com alta rotação, irá passar muitíssimas voltas até o relé desligar e até o motor parar. O ideal seria usar um controle pwm no motor e ao se aproximar do número desejado de voltas começa a diminuir. Nas últimas voltas irá girar quase parando. Outra opção seria usar 2 reles sendo 1 para máxima rotação e o outro para baixa rotação. Esta última tem que ser ajustada para coincidir o valor real de voltas desejado.
      Claudio

  7. 0

    desejo montar a ultima, Up Down, voce tem a BCP deste projeto, e como ficaria o arquivo HEX para usar display catodo, obrigado pela atencao!

    1. 0

      Olá Renato!
      Eu não fiz a placa de PCB, pois foi montado apenas em placa experimental (tipo protoboard). Para usar catodo comum, tem que mudar o programa e o esquema. Assim que tiver um tempinho vou dar uma olhada nisto.
      Cláúdio

  8. 0

    Gostaria de saber como eu faço para usar display de catodo comum pois so encontrei este em minha cidade, obrigado.

    1. 0

      Olá Renato!
      Tem que alterar o programa invertendo os valores passados para os dígitos. Qual versão você deseja montar?
      Cláudio

    2. 0

      Olá Renato!
      Poderá ver a versão no artigo original ou neste link aqui. Mas terá que se arranjar para fazer a placa de circuito impresso ou ver se algum colega do blog possa te disponibilizar.
      Cláudio

  9. 0

    Ola Claudio, gostaria de parabenizar pelo excelente site e dos posts. Me interessei muito neste contador de voltas e gostaria de monta-lo, mas uma parte eu não domino que é a confecção do circuito, Seria possivel me mandar o layout e o pcb deste circuito?
    Sem mais agradeço desde Ja.

        1. 0

          Olá João! Pode ser que algum colega do blog tenha feito, e fica aqui um pedido de ajuda neste sentido….
          Cláudio

          1. 0

            :mrgreen: Olá claudio e João, qual das versões acima vc esta com intenção de montar, me passe a versão que faço o desenho para vc e o claudio disponibilizar aqui no forum ok, abraço…

          2. 0

            Ola Aguinaldo, boa noite. Agradeço muito por se disponibilizar para a confecção da placa. O circuito é o de 2 sensores (UP/Down abaixo)a placa e a gravação do pic, pode dexar comigo.
            Mais uma vez, muito obrigado.

          3. 0

            :mrgreen: Ok Joao Luis, vc ja tem o display em mãos, e a peça mais critica para fazer o pcb,necessito das medidas ou seja o modelo(codigo)dele, agora se não tive vou fazer pelo o que tenho aqui ok. ai vc adquire
            o modelo que fiz a pcb, agora se vc for fazer a ligação por fios ja fica mais fácil, me retorna ai para que eu possa ja começar blz….

          4. 0

            Ola Claudio e Aguinaldo, boa noite. Os displays que eu tenho são: LC3971-11-M181 e o KW1-562AUAB e a conexão pode se feita por fios sim.

    1. 0

      Olá Valdeci!
      Os pontos de a, b,c,d,e,f,g do display de 7 seguimentos são interconectados nos 4 displays, ou seja, estão ligados em paralelos todos os 4 displays. Os anodos de cada um vão para os transistores que realizam a multiplexação. Os pontos a, b,c,d,e,f,g também são ligados aos mesmos pontos no pic. Ex. do esquema usando PIC 16f676: O ponto ‘a’ é ligado ao pino 10 do PIC através do resistor de 270 ohms. Ainda, o ponto ‘b’ é ligado ao pino 9 do PIC através do resistor de 270 ohms, e assim por diante. Os pontos ‘A,B,C’ são diferentes dos pontos ‘a, b, c’. Estes com letras maiúsculas se referem a polarização necessária para a logica do quarto display. Ex. do esquema usando PIC 16f676: Ponto ‘A’ do pino 8 é ligado ao ponto “A” do diodo 1n4148, idem para ‘B’ e “C’. O ‘ ponto’ não é usado nesta montagem, não sendo necessário sua ligação entre displays.
      Cláudio

  10. 0

    Olá Claudio, boa tarde.
    Estou chegando agora e já estou pedindo sua ajuda.
    Estou montando meus próprios transformadores e até já construí uma maquininha elétrica para isso (posso compartilhar o projeto com quem, aqui do fórum, se interessar).
    Desde de já, peço desculpas pelas perguntas primárias.
    Comprei todo o material para montar o circuito conta-voltas que será utilizada nessa maquina, inclusive, a placa para gravar o arquivo .HEX. Ainda sou ignorante nisso (PIC), conheço um pouco de válvulas (monto amplificadores valvulados), contudo, não sou totalmente cego em informática. Se puder, por favor, me informar como posso transformar o .TXT que vc enviou em .HEX ficarei muito agradecido.
    Junto com a placa veio um programa para gravação que só importa o .HEX, a partir daí precisarei de um arquivo.HEX para prosseguir a operação.
    Muito obrigado
    Nelson Mathias

    1. 0

      Olá Nelson!
      Por favor, tente renomear o arquivo para terminação ‘.hex’ e veja se consegue abrir. Se não, você poderá usar o WinPic800 para programar e o simples programador para pic (hardware) deste blog. Caso queira usar outro programador, poderá abrir com o WinPic800 e salva-lo como ‘.hex’. Para abrir com WinPic800, mude o filtro para o ‘tipo’ *.*. ao invés de ‘*.hex’. Também poderá usar o Mplab_ide para recompilar o arquivo asm, gerando um arquivo hex.
      Claudio

    2. 0

      Amigo se me permite uma ideia eu clico com o botão direito do mouse e seleciona salvar link como dai seleciona a pasta de destino e deleto o .txt e o traço antes do HEX
      ficando assim CONTA_VOLTAS.HEX , seleciona salvar tipo de arquivo como todos os aquivos . pronto ja é o hex preparado pra usar .

        1. 0

          💡 Olá Nelson seleciona todo este arquivo copia e salva em bloco de notas mesmo, mais com a extenção contador.hex, nada mais depois do *.hex, so carregar pelo o gravador e mandar gravar o pic. aqui deu certo desta forma. 😉

          :020000040000FA
          :020000002A28AC
          :08000800B000030EB1000B1162
          :1000100083122B0803398207102816281C2822284F
          :100020002008AC0094200615AB0A26282108AC0055
          :1000300094208615AB0A26282208AC0094200616C8
          :10004000AB0A26282308AC009420AB0A310E8300AB
          :10005000300809008316A0308B00C1308500C03005
          :10006000860083308100831207309F00850186015E
          :10007000A801A901A601AB01FC30A000A009A101C3
          :10008000A109A201A209A301A309A70105184628F5
          :100090000530A52005184628A80F4F28A90A2808CA
          :1000A000B4002908B300AC205820051C5528462868
          :1000B000360E0F39003E031D61282714A301A30942
          :1000C000652827108920A300A30936080F39003EB0
          :1000D000031D7028271C70282714A201A209742868
          :1000E00027108920A200A209350E0F39003E031DFA
          :1000F0007F28271C7F282714A101A1098328271402
          :100100008920A100A10935080F398920A000A00984
          :1001100008008207FC346034DA34F2346634B634D2
          :10012000BE34E034FE34F63485018601AC18051582
          :100130002C198514AC1986162C1A0516AC1A8515BF
          :100140002C1B8614AC1B06140800A600A501A50BE9
          :10015000A728A60BA72808001030B200B501B601E9
          :10016000B7010310B40DB30DB50DB60DB70DB20B3D
          :10017000BA280800033037070839083A031DC22897
          :100180000330B707303037078039803A031DCA285B
          :100190003030B707033036070839083A031DD22834
          :1001A0000330B607303036078039803A031DDA282D
          :1001B0003030B607033035070839083A031DE22806
          :1001C0000330B507303035078039803A031DEA28FF
          :0601D0003030B507B12834
          :02400E00703F01
          :00000001FF

  11. 0

    amigo desculpa pela postagem reamente é complicado não teria como vc me ajudar atraves desta postagem ?
    ou se possivel e se for pedir de mais bolar isso pra mim eu agradeço . vou ver o que posso fazer sobre o mplab , se quiser pode retirar esta postagem enorme do blog ok

    1. 0

      Olá Liliano! Quando a gente tem o esquema, sabe qual pino vai fazer o que, etc, talvez até daria para ‘tentar’ decifrar a ‘parafernalia’ gerada. Eu não tenho a menor idéia do que você está fazendo! Você está simulando um ht6p ou fazendo um PIC acionar ele? Você citou que deve acionar uma única vez. Seria para um tx do chama garçom? Se for, e se esta única transmissão coincidir com outra e não for aceita no receptor? Não seria interessante depois de um tempo ele ficar operante de novo?
      Claudio

      1. 0

        amigo é pro chama garçom mesmo , mas foi uma ideia que tive pois o que acontece eu fiz um flip flop para acender um led e manter e apagar com o cancela , ai funciona bem , o problema foi que fiquei pressionando o chama e assim bloqueou os demais controles a solução foi colocar um pic com um programa que pressionando o chama ele acionaria o ht6p20b por meio de um transistor pois o ht trabalha com 12V , ou por meio de divisor de tensão com zener , este pic ao mesmo tempo vai substituir o flip flop , assim ele acende o led e fica só apagando quando pressionado o cancela , entendeu amigo a possibilidade de apertar dois controles seria muito dificil e o garçom foi orientado a verificar sempre se na mesa tem o led acesso e se o numero0 esta acionado , o led serve para isso e para indicar pro cliente o funcionamento , o projeto que vc modificou ja esta em trabalho em um restaurante e funcionando bem

        1. 0

          Olá Liliano! Entendi. Que bom que conseguiu por pra funcionar a contento! Verei o que dá para fazer com o pic.
          Cláudio

        2. 0

          Olá Liliano! visite o blog do ‘Chamagarçom’ e veja se o ‘trava_graça’ é o que você deseja.
          Claudio

  12. 0

    amigo fiz este codigo no flowcode ele gerou o arquivo ASM , mas na pratica não funicona vc poderia me ajudar atraves deste asm modificar para que ele opere , o proposito é que quando aperto o botão aciona o ht6p20b e acende um led e mantem este led acesso e se pressionar o botão de chamada nada acontece só depois do botão cancela ser presionado então o botão aciona outro pino do ht6p20b , e apaga este led , o certo é travar o sistema para não transmitir o codigo novamente enquanto ja foi acionado uma vez , usei um pic12f675 para fazer isso assim consigo bloquear os engraçados que ficam apertando o botão de transmissão e travando o sistema

    o codigo

    ;/////////////////////////////////////////////////////////////////////////////////
    ;// Code Generator: BoostC Compiler – http://www.sourceboost.com
    ;// Version : 6.95
    ;// License Type : Full License
    ;// Limitations : PIC12,PIC16 max code size:Unlimited, max RAM banks:Unlimited, Non commercial use only
    ;/////////////////////////////////////////////////////////////////////////////////

    include “P12F675.inc”
    ; Heap block 0, size:24 (0x00000047 – 0x0000005E)
    __HEAP_BLOCK0_BANK EQU 0x00000000
    __HEAP_BLOCK0_START_OFFSET EQU 0x00000047
    __HEAP_BLOCK0_END_OFFSET EQU 0x0000005E
    ; Heap block 1, size:0 (0x00000000 – 0x00000000)
    __HEAP_BLOCK1_BANK EQU 0x00000000
    __HEAP_BLOCK1_START_OFFSET EQU 0x00000000
    __HEAP_BLOCK1_END_OFFSET EQU 0x00000000
    ; Heap block 2, size:0 (0x00000000 – 0x00000000)
    __HEAP_BLOCK2_BANK EQU 0x00000000
    __HEAP_BLOCK2_START_OFFSET EQU 0x00000000
    __HEAP_BLOCK2_END_OFFSET EQU 0x00000000
    ; Heap block 3, size:0 (0x00000000 – 0x00000000)
    __HEAP_BLOCK3_BANK EQU 0x00000000
    __HEAP_BLOCK3_START_OFFSET EQU 0x00000000
    __HEAP_BLOCK3_END_OFFSET EQU 0x00000000
    gbl_status EQU 0x00000003 ; bytes:1
    gbl_16_LSR EQU 0x00000020 ; bytes:4
    gbl_float_detect_tininess EQU 0x00000039 ; bytes:1
    gbl_float_rounding_mode EQU 0x0000003A ; bytes:1
    gbl_float_exception_flags EQU 0x0000003B ; bytes:1
    gbl_17_gbl_aSig EQU 0x00000024 ; bytes:4
    gbl_17_gbl_bSig EQU 0x00000028 ; bytes:4
    gbl_17_gbl_zSig EQU 0x0000002C ; bytes:4
    gbl_17_gbl_aExp EQU 0x0000003C ; bytes:1
    gbl_17_gbl_bExp EQU 0x0000003D ; bytes:1
    gbl_17_gbl_zExp EQU 0x00000037 ; bytes:2
    gbl_17_gbl_aSign EQU 0x0000003E ; bytes:1
    gbl_17_gbl_bSign EQU 0x0000003F ; bytes:1
    gbl_17_gbl_zSign EQU 0x00000040 ; bytes:1
    gbl_17_gbl_zSigZero EQU 0x00000041 ; bytes:1
    gbl_17_gbl_ret EQU 0x00000030 ; bytes:4
    gbl_indf EQU 0x00000000 ; bytes:1
    gbl_tmr0 EQU 0x00000001 ; bytes:1
    gbl_pcl EQU 0x00000002 ; bytes:1
    gbl_fsr EQU 0x00000004 ; bytes:1
    gbl_gpio EQU 0x00000005 ; bytes:1
    gbl_pclath EQU 0x0000000A ; bytes:1
    gbl_intcon EQU 0x0000000B ; bytes:1
    gbl_pir1 EQU 0x0000000C ; bytes:1
    gbl_tmr1l EQU 0x0000000E ; bytes:1
    gbl_tmr1h EQU 0x0000000F ; bytes:1
    gbl_t1con EQU 0x00000010 ; bytes:1
    gbl_cmcon EQU 0x00000019 ; bytes:1
    gbl_adresh EQU 0x0000001E ; bytes:1
    gbl_adcon0 EQU 0x0000001F ; bytes:1
    gbl_option_reg EQU 0x00000081 ; bytes:1
    gbl_trisio EQU 0x00000085 ; bytes:1
    gbl_pie1 EQU 0x0000008C ; bytes:1
    gbl_pcon EQU 0x0000008E ; bytes:1
    gbl_osccal EQU 0x00000090 ; bytes:1
    gbl_wpu EQU 0x00000095 ; bytes:1
    gbl_ioc EQU 0x00000096 ; bytes:1
    gbl_iocb EQU 0x00000096 ; bytes:1
    gbl_vrcon EQU 0x00000099 ; bytes:1
    gbl_eedata EQU 0x0000009A ; bytes:1
    gbl_eeadr EQU 0x0000009B ; bytes:1
    gbl_eecon1 EQU 0x0000009C ; bytes:1
    gbl_eecon2 EQU 0x0000009D ; bytes:1
    gbl_adresl EQU 0x0000009E ; bytes:1
    gbl_ansel EQU 0x0000009F ; bytes:1
    gbl_FCV_ANSEL EQU 0x00000042 ; bytes:1
    gbl_FCV_BOTAO1 EQU 0x00000043 ; bytes:1
    gbl_FCV_BOTAO2 EQU 0x00000044 ; bytes:1
    CompTempVar2205 EQU 0x00000045 ; bytes:1
    CompTempVar2206 EQU 0x00000046 ; bytes:1
    CompTempVar2207 EQU 0x00000045 ; bytes:1
    CompTempVar2208 EQU 0x00000045 ; bytes:1
    CompTempVar2209 EQU 0x00000045 ; bytes:1
    CompTempVar2211 EQU 0x00000045 ; bytes:1
    delay_ms_00000_arg_del EQU 0x00000045 ; bytes:1
    Int1Context EQU 0x0000005F ; bytes:1
    Int1BContext EQU 0x00000034 ; bytes:3
    ORG 0x00000000
    GOTO _startup
    ORG 0x00000004
    MOVWF Int1Context
    SWAPF STATUS, W
    BCF STATUS, RP0
    MOVWF Int1BContext
    SWAPF PCLATH, W
    MOVWF Int1BContext+D’1′
    SWAPF FSR, W
    MOVWF Int1BContext+D’2′
    BCF PCLATH,3
    BCF PCLATH,4
    GOTO interrupt
    ORG 0x00000010
    delay_ms_00000
    ; { delay_ms ; function begin
    MOVF delay_ms_00000_arg_del, F
    BTFSS STATUS,Z
    GOTO label1
    RETURN
    label1
    MOVLW 0xF9
    label2
    ADDLW 0xFF
    BTFSS STATUS,Z
    GOTO label2
    NOP
    DECFSZ delay_ms_00000_arg_del, F
    GOTO label1
    RETURN
    ; } delay_ms function end

    ORG 0x0000001C
    main
    ; { main ; function begin
    MOVLW 0x20
    BSF STATUS, RP0
    MOVWF gbl_ansel
    MOVLW 0x07
    BCF STATUS, RP0
    MOVWF gbl_cmcon
    MOVLW 0xC0
    BSF STATUS, RP0
    MOVWF gbl_option_reg
    MOVLW 0x01
    BCF STATUS, RP0
    MOVWF gbl_FCV_BOTAO1
    MOVWF gbl_FCV_BOTAO2
    label3
    CLRF gbl_FCV_ANSEL
    MOVLW 0xFE
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFE
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF gbl_gpio
    MOVLW 0xFD
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFD
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF gbl_gpio
    MOVLW 0xFB
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFB
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF gbl_gpio
    MOVLW 0x10
    BSF STATUS, RP0
    IORWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0x10
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF CompTempVar2205
    CLRF CompTempVar2206
    MOVLW 0x10
    SUBWF CompTempVar2205, W
    BTFSC STATUS,Z
    INCF CompTempVar2206, F
    MOVF CompTempVar2206, W
    MOVWF gbl_FCV_BOTAO1
    MOVF gbl_FCV_BOTAO1, F
    BTFSS STATUS,Z
    GOTO label4
    MOVLW 0xFE
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFE
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF CompTempVar2207
    MOVLW 0x01
    IORWF CompTempVar2207, W
    MOVWF gbl_gpio
    MOVLW 0xFD
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFD
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF CompTempVar2208
    MOVLW 0x02
    IORWF CompTempVar2208, W
    MOVWF gbl_gpio
    MOVLW 0xFF
    MOVWF delay_ms_00000_arg_del
    CALL delay_ms_00000
    MOVLW 0x91
    MOVWF delay_ms_00000_arg_del
    CALL delay_ms_00000
    MOVLW 0xFE
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFE
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF gbl_gpio
    label4
    MOVF gbl_FCV_BOTAO1, F
    BTFSS STATUS,Z
    GOTO label3
    label5
    MOVLW 0x08
    BSF STATUS, RP0
    IORWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0x08
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF CompTempVar2209
    CLRF gbl_FCV_BOTAO2
    MOVLW 0x08
    SUBWF CompTempVar2209, W
    BTFSC STATUS,Z
    INCF gbl_FCV_BOTAO2, F
    MOVF gbl_FCV_BOTAO2, F
    BTFSS STATUS,Z
    GOTO label5
    MOVLW 0xFD
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFD
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF gbl_gpio
    MOVLW 0xFB
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFB
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF CompTempVar2211
    MOVLW 0x04
    IORWF CompTempVar2211, W
    MOVWF gbl_gpio
    MOVLW 0xFF
    MOVWF delay_ms_00000_arg_del
    CALL delay_ms_00000
    MOVLW 0x91
    MOVWF delay_ms_00000_arg_del
    CALL delay_ms_00000
    MOVLW 0xFB
    BSF STATUS, RP0
    ANDWF gbl_trisio, W
    MOVWF gbl_trisio
    MOVLW 0xFB
    BCF STATUS, RP0
    ANDWF gbl_gpio, W
    MOVWF gbl_gpio
    GOTO label3
    ; } main function end

    ORG 0x000000AD
    _startup
    MOVLW 0xD5
    BCF STATUS, RP0
    MOVWF gbl_16_LSR
    MOVLW 0xC4
    MOVWF gbl_16_LSR+D’1′
    MOVLW 0xBB
    MOVWF gbl_16_LSR+D’2′
    MOVLW 0xDC
    MOVWF gbl_16_LSR+D’3′
    CLRF gbl_17_gbl_aSig
    CLRF gbl_17_gbl_aSig+D’1′
    CLRF gbl_17_gbl_aSig+D’2′
    CLRF gbl_17_gbl_aSig+D’3′
    CLRF gbl_17_gbl_bSig
    CLRF gbl_17_gbl_bSig+D’1′
    CLRF gbl_17_gbl_bSig+D’2′
    CLRF gbl_17_gbl_bSig+D’3′
    CLRF gbl_17_gbl_zSig
    CLRF gbl_17_gbl_zSig+D’1′
    CLRF gbl_17_gbl_zSig+D’2′
    CLRF gbl_17_gbl_zSig+D’3′
    CLRF gbl_17_gbl_aExp
    CLRF gbl_17_gbl_bExp
    CLRF gbl_17_gbl_zExp
    CLRF gbl_17_gbl_zExp+D’1′
    CLRF gbl_17_gbl_aSign
    CLRF gbl_17_gbl_bSign
    CLRF gbl_17_gbl_zSign
    CLRF gbl_17_gbl_zSigZero
    CLRF gbl_17_gbl_ret
    CLRF gbl_17_gbl_ret+D’1′
    CLRF gbl_17_gbl_ret+D’2′
    CLRF gbl_17_gbl_ret+D’3′
    CLRF gbl_float_rounding_mode
    CLRF gbl_float_exception_flags
    CLRF gbl_float_detect_tininess
    BCF PCLATH,3
    BCF PCLATH,4
    GOTO main
    ORG 0x000000D4
    interrupt
    ; { interrupt ; function begin
    BCF STATUS, RP0
    SWAPF Int1BContext+D’2′, W
    MOVWF FSR
    SWAPF Int1BContext+D’1′, W
    MOVWF PCLATH
    SWAPF Int1BContext, W
    MOVWF STATUS
    SWAPF Int1Context, F
    SWAPF Int1Context, W
    RETFIE
    ; } interrupt function end

    ORG 0x00002007
    DW 0x3F94
    END

    1. 0

      Olá Liliano! Ninguém merece debugar asm gerados por compilador ‘C’!!! Faça o seguinte: Jogue este arquivo em um texto.asm e compile no IDE do Mplab. Aí voce poderá usar os recursos para acompanhar linha a linha, a condição dos registradores e se fazem o que deveriam fazer.
      Claudio

  13. 0

    :mrgreen: Olá Claudio, esta ideia do nosso colega Liliano e boa, a quantidade de volta vc digita em um teclado matriz e quanto ao motor seria intereçante ser o de passo, pois ele pode parar no ponto exato da contagem, apenas um palpite 💡 Abraços..

  14. 0

    Então amigo o motor que eu usava era AC , mas o ideal seria de passo , usao crescente para desenrolar transformador e contar as espiras , depois para facilitar ja pronto usava o sistemna decrescente , só que o meu sistema antigo a placa era enorme , nem sei se tenho o esquema dela mas posso desenhar se for o caso , a maquina seria automatica tipo , seleciona o numero de espeiras ela parte a contagem pelo botão start , quando atingir proximidade do final reduz a velocidade do motor de passo , e ao tremino bloqueia a contagem e avisa com um sinal sonoro , seria inetresante se o proprio pic controlasse o motor e se pudesse ter uma saida para acionar um motro simples para fazer o corte do cobre , masi ai se trata de um pic com mais portas

    1. 0

      Olá Liliano!
      Sem dúvida, não seria um projeto pequeno. Eu já enrolei pequenos transformadores na ‘mão’, mas como, usando um motor elétrico, você controla para que o fio não se sobreponha? É por tensão mecânica sobre o fio (como nas máquinas de costuras que mantém o fio sempre esticado)? E quando se trata de fios de diâmetro extramente pequenos? Como faz para que não quebre ? A velocidade é escolhida conforme o diâmetro do fio? O diâmetro da forma entra no cálculo da rotação? Qual a rotação máxima atingida por este motor?
      Cláudio

      1. 0

        então amigo , eu esticava o fio mesmo , e cheguei a enrolar fios bem finos , se tiver bem alinhada e lubrificada é muito dificil arrebentar , coloquei um sensor de passagem e prendi um circulo no eixo do motor , e colei uma fita preta neste sensor ele contaria a volta completa do eixo sendo assim a forma não influenciava na contagem , sobre o fio arrebentar coloquei um sensor micro sw onde o fio fazia uma presão ele fica acionado se o fio quebrasse desligava toda a maquina , amigo sobre a velocidade eu trabalhava com um motor AC de maquina de costura tinha um pedal com reostato podia variar esta velocidade pisando no pedal .

        1. 0

          Olá Liliano! Obrigado pela explicação. Gostei do seu método. Ví alguns videos aonde o pessoal usa ‘calculadora’ como contador de volta. ‘Jeitinho brasileiro’!
          Cláudio

  15. 0

    Ola Claudio Bom dia, você teria como você fazer um exemplo com o ds1307 relógio com data hora e minuto e segundo estou com dificuldade em um trabalho referente a um curso que estou fazendo.
    Obrigado

    1. 0

      Olá Ronaldo!
      O DS1307 se comunica com um microcontrolador usando protocolo i2c. Infelizmente, não disponho deste ci no momento, para testes. Poderá ver, para ter uma idéia, com a seguinte Note Application da Maxim: ‘Using a DS1307 with PIC”. Fornece um exemplo de uso com o Pic 16f628.
      Claudio

  16. 0

    Ola amigo 2 duvidas , teria como fazer este projeto com 16f628 ?
    outra coisa eu vi uma vez um exemplo na internet só não me lembro onde mas ele tinha a opção de selecionar o numero de parada , opção para cresente e decrescente , seria interessante também uma saida para ligar um relê e poder desligar todo o sistema assim poderia ser programado as voltas e o sistema parar sozinho , eu fiz uma fez um contador assim usando cis digitais cd4017 , contador decada e o 4026 contador com ja com opção paraligar o display direto , assim usando uma porta AND de 4 portas eu podia selecionar os 4 digitos e com a opção de escolher o numero para parar assim coloquei um motor e o sistema todo automatico mas gigante rsrsrs , tipo 4 cis contadores , 4 cis 4017 para selecionar o numero e 1 ci porta AND , fora os transistores e resistores , com um simples pic faria isso tudo .

    1. 0

      Olá Liliano!
      Migrar para o 16F628 é uma operação simples, com mudança de arquivos de definição e ajustando as portas corretas (não tem portc, mas ‘portb’). Quanto a fazer de forma automática, é possível sim. Poderia fazer um descritivo ‘ detalhado’ do que tem que fazer a ‘maquina’? Quando se usaria a opção ‘decrescente’? Você consegue ainda achar o artigo, para analisar como deve ser operado? Que tipo de motor deve ser usado? Corrente alternada, corrente continua , motor de passo?
      Claudio

Comments are closed.