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 foto-transistor. Poderá ser usado os reed pequenos em envólucro 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 milissegundos. 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 foto-sensível), controle de fluxo de pessoas (uma ‘catraca’ eletrônica) e muitos outros usos.
Obs. Este material foi montado apenas em breadboard, 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:
Segue o arquivo HEX:
Segue o arquivo ASM para versão com pic 16f628a:
Segue o arquivo HEX para versão com pic 16f628a:
Também, em 15/08/2015 foi postado esta versão com 16f628a, usando câtodo comum. Abaixo segue a pasta com os arquivos desta versão:
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 foto-transistores 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 foto-transistor sejam acionados ao mesmo tempo, uma vez por volta. O funcionamento é bem simples:
Quando giramos para um lado, encontramos primeiro o foto-transistor da entrada ‘trig’ (por ex.). A outra entrada ainda está em nivel ‘1’, pois não foi acionado o foto-transistor da entrada ‘dir’. Ocorrerá um decremento. Virando ao contrário, acionamos o foto-transistor da entrada ‘dir’ e continuando o giro, quando o disco permite iluminar o foto-transistor 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”:
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:
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:
Em 17/11/2017 foi alterado o arquivo em “C” para salvar a contagem na EEprom interna do PIC em caso de falha no fornecimento da energia elétrica. Foi necessário alterar o esquema para usar mais um pino do PIC como sensor de tensão da rede. Segue a pasta zipada com esta versão:
Manuais:
Datasheet PIC16F676
Datasheet PIC16F628a
Curiosidades:
O eterno fascínio pelo ouro
O sistema de navegação das tartarugas
Os eficientes e versáteis escudos da Terra
Vespões constroem com imãs
O universo – cheio de surpresas
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 necessidades especiais
Como ser um bom pai
Como lidar com dívidas
Como resolver diferenças no casamento
Como tratar o cônjuge com respeito
Como evitar ferir com palavras
Ensine seus filhos bons princípios 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!!!
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
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
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
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
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 .
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
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
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
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 .
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