Hoje encontramos no mercado, transmissores de controle remoto para portão e alarmes com vários circuitos integrados. Que tal um único código em que pudéssemos optar qual modelo usar?
Analisando as muitas situações de uso para os controles remotos, desejei tentar fazer um programa que atendesse as mais variadas necessidades dos hobistas. Por exemplo: Um artigo é postado para um receptor usando um HT6P20b, com 2 canais. Surge alguém que precisa de 3 canais. Outro hobista deseja um canal invertido. Ainda outro, que a saída seja em modo ‘retenção’ para todos os pinos. Sem falar dos que desejam um pino em modo ‘pulso’ e outros em ‘retenção’. Realmente se torna um pouco ‘enfadonho’, escrever e reescrever os códigos já publicados, com estas simples alterações. Também, em muitas localidades não se encontra determinado integrado usado na montagem, mas existe de outros modelos. Surgiu a ideia de escrever um código em que fosse possível montar nosso receptor a ‘LA CARTE’. Cada hobista escolheria sua opção e marcaria no código. Depois é só compilar e carregar o PIC.
As características desejadas obtidas neste código são estas:
1) Opção de escolher qual integrado do transmissor iremos decodificar. Assim, poderá ser optado pelo ci HT6P20B, PT2262,PT2240B e família HCS 200 …301 (somente em modo fixo, sem usar o HOPPING CODE).
Obs. Apenas um modelo pode ser usado por vez.
2) Opção de escolher de forma individual, se as saídas serão em modo ‘PULSO’ ou ‘RETENÇÃO’.
3) Opção de escolha de forma também individual, se as saídas serão ‘invertidas’ ou ‘normais’.
4) Opção por aprendizado único de todos os botões (para uso em um único aparelho) ou aprendizado individual (para uso com vários aparelhos)
5) Escolher entre o PIC 12f675 ou 629.
6) Escolher carregar um byte de calibração provisório (em situações de perda deste de forma acidental). Os Pics ‘encostados’ , por não funcionarem em programas gerados em compiladores ‘C’, pela falta deste byte de calibração, poderão ser reaproveitados.
7) Possibilidade de mudar quais pinos serão usados, respeitando as limitações para pinos específicos.
Outra necessidade é que fosse em uma linguagem mais ‘usual’ e não no ‘Assembly’, pois muitos tem ‘aversão’, uma genuína ‘idiossincrasia’ só da menção do nome desta nobre linguagem. Dando os primeiros passos na linguagem “C”, portanto, esta foi a linguagem escolhida para este humilde projeto de iniciante. Creio que, para quem já é experiente nesta linguagem, não terá dificuldade em alterar e talvez simplificar as linhas de código. Mas foi o que consegui e portanto, estou compartilhando. Todas sugestões serão bem recebidas, de como fazer de uma forma melhor.
Voltando ao código, foi usado o compilador CCS C para a compilação, podendo ser usado a versão de demonstração. Logo no início do programa, podemos alterar nossas escolhas em ‘Opções do Usuário’, por comentar ou descomentar as linhas relacionadas as opções.
A rotina faz uso da interrupção do Timer 0 a cada 100 microssegundos, para analisar o estado da entrada que tem o sinal do receptor de 433mhz (RFIN, pino 3). Se for ‘0’, irá incrementar o contador ‘LC’ e acionar o flag_L. Depois, quando a entrada ficar ‘1’, irá incrementar o contador ‘HC’. Quando a entrada rfin ficar ‘0’ novamente, será analisado se o contador ‘LC’ estourou um valor máximo, o que indicaria um intervalo grande (pausa entre transmissões) e que servirá de sincronização do sinal. Se o valor de ‘LC’ ficou abaixo do permitido, haverá uma subtração de ‘LC’- ‘HC’, cujo valor do ‘carry’ será deslocado para dentro do buffer de recepção de 3 bytes e resetando ‘LC’, ‘HC’ e o ‘flag_L’, em preparação para um novo bit a ser recebido. Ao final de 24 bits recebidos (ou 64 no HCS) teremos uma recepção completa. Isto será sinalizado por setar o ‘flag_rok’. São feitas 2 recepções para comparar e eliminar erros de transmissão. Depois a rotina procura na memória pelo número transmitido (serial number), se já foi aprendido na memória. Se foi, irá acionar as saídas de acordo com as opções escolhidas pelo usuário. Se não, irá verificar se o botão ‘LEARN’ foi apertado (e o led ‘learn’ deverá estar aceso). No caso de ter sido apertado, será gravado este número recebido na EEprom e apagará o led “LEARN’. Com respeito a recepção do HCS, foi aproveitado apenas parte do serial number (HCS usa 28 bits + 4 botões= 32 bits ou 4 bytes da parte ‘fixa’ + 32 bits ou 3 bytes na parte encriptada, mas são gravados na EEprom apenas 22 bits + 2 bits dos botões). A razão desta decisão foi dar compatibilidade com os outros controles que usam apenas 3 bytes para o serial number.
Atenção: Este programa é de caráter didático apenas, sujeito a bugs ainda não detectados.
Segue o arquivo ‘C’:
Segue pasta zipada com os arquivos do projeto (10/11/2013):
Segue pasta zipada com os arquivos do projeto ( atualizada em 17/12/2016):
Segue pasta zipada com os arquivos do projeto, sendo esta uma versão que salva o estado das saídas em retenção na EEprom do pic e retorna no seu reset ( 17/12/2016):
E versão (em teste) para ht6p20d também:
Como a montagem permite muitíssimas combinações de circuitos integrados e modos de operação, ficará evidente porque não tentei fornecer o arquivo Hex. Cada hobista deverá escolher a suas opções e recompilar, para obter o arquivo HEX.
Obs. Ainda não obtive retorno do funcionamento do código para PT2262, sendo testado apenas com o clone do PT2262 deste blog.
Segue os esquemas de 4 sugestões de montagens, onde temos receptores de 1 a 4 canais:
Manuais:
HCS200
PT2262
PT2240b
Pic12F675
Curiosidades:
O rio que teve seu curso invertido
Outros grandes terremotos estão por vir
Será que Deus é o responsável?
Teve um Projeto? O econômico peixe-cofre
Por que a cooperação é essencial
Como poderá manter um conceito equilibrado sobre o dinheiro?
Sou viciado em aparelhos eletrônicos?
20 modos de criar mais tempo
Dengue — uma ameaça crescente
Preservados numa gota dourada
O “mundo perdido” da Bolívia
Outros assuntos:
Um site para você
Como disciplinar seu filho adolescente
Por que eu me corto?
Desempenhem bem o papel de pais
Como fazer seu segundo casamento dar certo
O que acontece quando morremos?
Como criar filhos responsáveis
Como administrar o seu dinheiro
Ensine valores morais a seus filhos
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
Adolescentes- O que fazer se estou sofrendo bullying?
Como evitar ferir com palavras?
Como tratar seu cônjuge com respeito?
Perguntas Bíblicas Respondidas
Até o próximo artigo!!!
Olá Claudio Larios, sou novato no seu site. Eu baixei seu programa RX_GEN_FLE_C, para utilizar TX com HT6P20B. Compilei seu programa e gravei no 12f675. Fiz primeiramente as configurações no seu programa antes compila-lo. Mas ao pressionar para aprender o led learn acende esperando o comando dos botões do tx. mas não aceita a recepção. Fiz a montagem no protoboard para testa-lo. Os seus programas com condigo Assembly fincionam blz. Mas estou tendo dificuldade de encontrar o problema. Estou precisando de um receptor com 3 canais, mas preciso que os botões sejam gravados de forma independente.
Olá Gralves!
Por favor, não esqueça de conferir as configurações de usuário, em especial se está usando a opção para Ht6p20b.
Confira usando o esquema, para ver se não tem algum erro de montagem, em especial a entrada do pino 4 ligado ao receptor de rf. Use um piezo elétrico ligado a este pino (ou um osciloscópio) para ter certeza que o sinal chega ao apertar o controle remoto. Se não chegar, verifique a frequência do tx se é igual ao do rx usado.
Cláudio
Boa noite Claudio. Muito obrigado por responder. No pino 2 eu coloquei um led, e com alguns tx que tenho na minha oficina, e que usa o ht6p20b, eu fiz algumas tentativas. Com um deles, o botão direito, eu consegui acender esse led no pino 2, mas não acionou nenhuma saida. Ja revisei varias vezes as configurações e não achei nada ainda. A montagem no proto board esta correta, por teste outros projetos seu no assembler, esta ok. Inclusive, as vezes voce me ajuda a fazer um ajuste nesse RX_GEN_HT6P20B_V10P1.ASM, que trava um dos leds. Estou tentando mexer no seu programa para trabalhar como os outros,com pulso mas estou com dificuldade, devido a meu pouco dominio do assembler. Esse me atende se me disser como mudar.
Olá caro Larios, é impossível deixar algum comentário com alguma pergunta sem antes parabeniza-lo pelo blog, seus projetos são fantasticos… Parabens!!
Seguinte, gravei um 12f675 com o codigo para pulso/aprender todos botões..funcionou certinho!!. Agora me surgiu uma duvida…
Se precisar, como faço para apagar um controle ja gravado???
Desde já muito obrigado!!!!!
Olá RodrigoCirilo!
Agradeço seu comentário de apreço pelos artigos do blog. Para realizar o apagamento de todos os controles, deverá apertar o botão ‘Learn’ por mais de 5 segundos. Não há recurso para apagamento individual de um determinado controle. Apague todos e grave os que irá efetivamente usar ( em caso de perda de algum “chaveirinho”).
Cláudio
Boa noite
Estou tempo um certo problema na familia dos HCS
o receptor até apaga o led pós apertado a tecla do controle mas as saidas após a programação não sao acionadas, fiz varias configurações e teste com varios controle mas não está funcionando. Obrigado
Olá Cladinei!
Trabalhar com HCS não é muito fácil não. Lembre-se que terá que reprogramar cada HCS dos controles que adquiriu para a sua Key de decodificação. Terá que usar um programador profissional de HCS, ou usar uma sugestão deste blog no artigo ‘ hcs_prog_v628 – mais uma opção para programar hcs200…301 …’ Depois terá que usar a mesma Key no programa que vai rodar no microcontrolador. Isto exige trocar no arquivo asm e recompilar novamente no Mplab.
Não adianta tentar funcionar os controles sem primeiro programar os HCS para sua Key (ou a key ‘default’ do programa asm ). Releia os artigos relacionados a HCS. Tenha uma boa idéia de seu funcionamento. Siga os passos dos artigos para conseguir ser bem sucedido.
Claudio
Olá Cladinei!
O comentário anterior não se aplica se você estiver usando apenas a porção fica do código do HCS.
Claudio
Olá Cláudio,
Então vamos lá!
1) Definir a forma que irá captar a intenção de canal desejado para o acionamento, já na hora de gravar um controle (talvez por meio de botão/jumpers, etc)
RESPOSTA: A FORMA QUE O CANAL SERÁ CAPTURADO É COM O DIP SWITCH COM 8 SAÍDAS.
2) Salvar um byte a mais na eeprom, junto com o serial number recebido do tx, para guardar esta intenção de canal desejado
RESPOSTA: APRENDI A GRAVAR E LER UM BYTE NA EEPROM, PORÉM NÃO SEI COMO LOCALIZÁ-LO PARA ARMAZENAR NO BUFFER, NO QUAL FAREI A COMPARAÇÃO DOS BIT.
3) alterar a rotina de recepção para pular este byte a mais, na hora de comparar o serial number recebido, tanto na leitura e na gravação de controles, mas salva-lo para uso na recepção de um controle, de maneira a direcionar o acionamento para o canal desejado.
RESPOSTA: JUSTAMENTE ISSO QUE TENTEI E TAMBÉM NÃO CONSEGUI.
Sou leigo e estou me esforçando para aprender 😕 Tem como dar uma 💡 para mim?
Desde já agradeço.
Olá xuguinho!
Você terá que alterar as rotinas de procura de lugar livre na eeprom ( ‘LOCALIZA ENDEREÇO LIVRE NA EEPROM PARA GRAVAR TX RECEBIDO’), a de procura por tx já gravado na eeprom (‘LOCALIZA TX RECEBIDO SE GRAVADO NA EEPROM’), e de gravação de um novo tx ao apertar o botão ‘learn’ (‘GRAVAR TX RECEBIDO NA EEPROM’), bem como suas menções ao longo do programa.
Poderia se pensar em alterar para algo assim:
//==============================================================================
// GRAVAR TX RECEBIDO NA EEPROM
// obs. Mudado para 4 bytes
// qcanal deverá estar com os valores já definidos antes de chamar esta rotina
//==============================================================================
void grava_4bytes_eeprom (int address_init, int *pont){
// onde int_addres = endereço inicial da gravação
// *pont = endereço inicial da informação (3 bytes seguidos)
int a;
for (a=0;a<3;++a){ // copia buffer para sbuffer
write_eeprom(address_init + a,*pont++);
}
write_eeprom(address_init +3, qcanal);
}
//==============================================================================
// LOCALIZA ENDEREÇO LIVRE NA EEPROM PARA GRAVAR TX RECEBIDO
// obs. Mudado para procurar 4 bytes vazios consecutivos
//==============================================================================
int procura_4bytes_livres_eeprom () {
int a;
for (a=0;a<128;a+=3){ // copia buffer para sbuffer
if(read_eeprom(a)==0xff){
if(read_eeprom(a+1)==0xff) {
if(read_eeprom(a+2)==0xff) {
if(read_eeprom(a+3)==0xff) {
return a;
}
}
}
}
}
return 0xff;
}
//==============================================================================
// LOCALIZA TX RECEBIDO SE GRAVADO NA EEPROM
//obs. Procura de 4 em 4 bytes e pega o byte com informação de canal desejado
// e salva no registrador ‘configcanal’.
//==============================================================================
int procura_4bytes_gravados_eeprom (int *pont) {
int a;
for (a=0;a<123;a+=4){ // copia buffer para sbuffer
if(read_eeprom(a)==*pont){
if(read_eeprom(a+1)==*(pont +1)) {
if(read_eeprom(a+2)==*(pont+2)) {
configcanal= read_eeprom(a+3);
return 0xaa;
}
}
}
}
return 0xff;
}
Você terá que pegar a informação da chave 'dip' e passar para o registrador 'qcanal' antes de gravar um tx e deverá prover rotinas adicionais para usar o conteúdo gravado lido através do registrador 'configcanal', ao receber um tx, de maneira a acionar os canais desejados com os respectivos botões. Esta parte é você que deve 'bolar'.
Cláudio
Olá Cáudio!
Boa tarde,
Entendi. Dessa vez vai dar certo. Muito agradecido pelas dicas. Vou alterar o código e efetuar alguns testes. Você é o cara!!! Um abraço e bom fim de semana.
Bom dia Cláudio. Mais uma vez,
muito obrigado por responder minhas perguntas.
Entendi sua resposta. Então seria a formação
do byte com o hexa C6, que é igual ao
binário 11000100, onde Buffer[2] compararia
a variação dos últimos bits (11). Correto?
Ainda me restou uma dúvida: Voltando a
string que foi recebida pelo botão do controle
( C6F06D ), como faria para comparar outro par
de hexadecimal para testar os bits 7 e 6? Por exemplo:
Sei que buffer[2] = C6. E Buffer[1] comparararia os bits 6 e 7 existentes
no hexadecimal F0? E o Buffer[0]?
Tentei de todas as formas mas não consegui fazer com que o código
comparasse com outros bits dos pares de hexadecimal existente na string.
Quero adicionar mais outro par de hexa, ou no início ou no final, para
escolher qual saída acionarei ao pressionar um botão e tico e teco deu
uma travada. Me dê uma dica com seu super core i7 aí!!!
Um abraço e até mais.
Olá xuguinho!
Eu não estou entendendo o porque de comparar os outros pares com os bits 6 e 7. Mas a várias formas de fazer isto: por ex. poderia isolar um ou mais bits de um byte usando a função ‘and’:
if(( buffer[1] &0b11000000 )==( buffer[0] &0b11000000 )) { //fica somente os bits ‘6’ e ‘7’ de cada byte a comparar e se forem iguais , faz alguma coisa
rotina faz alguma coisa
}
else{
rotina faz outra coisa
}
Mas o que você pretende precisa ser feito em varias etapas:
1) Definir a forma que irá captar a intenção de canal desejado para o acionamento, já na hora de gravar um controle (talvez por meio de botão/jumpers, etc)
2) Salvar um byte a mais na eeprom, junto com o serial number recebido do tx, para guardar esta intenção de canal desejado
3) alterar a rotina de recepção para pular este byte a mais, na hora de comparar o serial number recebido, tanto na leitura e na gravação de controles, mas salva-lo para uso na
recepção de um controle, de maneira a direcionar o acionamento para o canal desejado.
Claudio