RECEPTOR GENERICO FLEX – UM PROGRAMA PARA VARIAS OPÇÕES DE CIRCUITOS INTEGRADOS – COM PIC 12F675/629 (REF126)

2

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’:

RX_GEN_FLEX_C

Segue pasta zipada com os arquivos do projeto (10/11/2013):

arquivos_projeto_c

Segue pasta zipada com os arquivos do projeto ( atualizada em 17/12/2016):

RX_GEN_FLEX__

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):

rx_gen_flex__eep.c

E versão (em teste) para ht6p20d também:

RX_GEN_FLEX_4_C

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!!!

2

113 comments

  1. 0

    Boa noite Claudio, deixa eu te perguntar? esse código pode ser adaptado para usar um 16F877A invés de programar 4 saídas programar 32 saídas?
    Sérgio

    1. 0

      Olá Sérgio!
      Este programa trabalha com htp20b ou htp20d . Esses somente dispõem respectivamente de 3 e 4 canais Talvez possa usar o tx/rx de 32 canais publicado recentemente neste blog.
      Cláudio

  2. 0

    Bom dia Claudio! eu de novo! rsrs sobre o sensor de toque capacitivo que tinha comentado em post anterior vou postar os links do site onde achei, não estou no meu pc, mas preciso perguntar uma coisa pra você se seria possível nesse “receptor flex” gravar estado do pino no modo retenção para que na falta de energia ele retornasse no mesmo estado. Seria possível?
    Atenciosamente
    Sérgio

    1. 0

      Olá Sergio!
      Terei que dar uma olhada antes de responder. O programa trabalha com muitas opções que acabam complicando qualquer mudança.
      Cláudio

  3. 0

    Boa tarde Claudio
    estou tentando aprender programar , voce poderia me ajudar como programo 12f629 , para receptor 3 canais 433 mhz .
    obrigado

      1. 0

        Pois não comprei o programador picburner usb k 150
        pois ja programei arduino pelo que eu vi o programador so aceita em hex , gostaria de saber se voce da aulas sobre como programar .

        1. 0

          Olá James!
          Você poderá obter bastante informação de uso do equipamento consultando o seu manual e adicionalmente, o forum do fabricante. A maioria dos programadores para pic só funcionam com o arquivo hex. Outros fabricantes podem usar nomenclatura diferente em seus arquivos. Para aprender a programar, vá no Youtube e veja videos sob o titulo ‘programar pic’, onde você terá muita informação desde do básico até criar arquivos em ‘C’. Eu não dou aulas de programação, pois sou apenas hobista nesta área.
          Cláudio

          1. 0

            Claudio certo vou verificar ,
            não consegui abrir os arquivos compactados que você deixou pois lá tem em hexa a programação para 3 canais ?
            obrigado pela atenção .

          2. 0

            Olá James!
            Nesta pasta tem um arquivo hex, mas para uma versão especifica de circuito integrado. Para outras versões, deverá alterar nas ‘opções de usuário’ do arquivo C e recompilar usando o compilador CCS C. Desta forma, irá obter o arquivo hex apropriado para a sua montagem.
            Cláudio

  4. 0

    Hallo Claudio 🙂
    I’m trying to do 4-chanel receiver for IC EV1527, but I have enough experience. Can you help me ? 🙂
    Best wishes from Bulgaria 🙂

    1. 0

      Barlog Hello !
      Unfortunately I do not know this chip and I will not know how to help you. Try other blogs dealing with the subject .
      Thanks!
      Cláudio

  5. 0

    Boa Noite Cláudio, tudo bem, Parabéns pelo artigo, naveguei bastante na net procurando como decodificar o ht6p20 em código C, encontrei somente o seu. Gravei, funcionou certinho. Gostaria de fazer umas modificações para se adaptar as minhas necessidades, mas mesmo com seus comentários no código estou encontrando dificuldades.
    Preciso fazer o seguinte:

    Gravar os botões, e tratar alguns tempos dentro do pic.
    Exemplo.
    Botão 1 se apertado, conta 30 segundo e desliga pino2
    Botão 2 se apertado, conta 40 segundos e desliga pino2
    Botão 3 se apertado, conta 40 segundos e desliga pino2

    Desde já agradeço.

    1. 0

      Olá Rony! Realmente, alterar este código fica meio confuso com tantas opções ! Talvez possa nomear as saídas (_s1…_s3) para serem flag. Então, no final do main você usa estes flag para acionar as saídas em rotinas de tempo dinâmicas (a cada loop do main decrementa uma variável que ao chegar à zero liga/desligá a saida desejada.)
      Claudio

      1. 0

        Entendi Cláudio, na verdade o que preciso mesmo é entender melhor a decodificação do ht6p20b, com certeza por falta de conhecimento meu, só preciso fazer, por exemplo, o botão 1 mudar o estado de uma variável “liga” (exemplo)
        botão 2 mudar estado de variável “liga1”
        botão 3 mudar estado de variável “liga2”, o restante creio que consigo, seria o mais básico mesmo.

        Precisava de primeiro gravar o código gerado pelo botão 1 na memória e quando apertado depois de gravado, buscar na memória se for igual acionar uma variável, isso para os três botões, o restante eu trabalho aqui.
        Se possível me ajudar agradeço, pois nem meus professores de faculdade sabem me ensinar, estou no terceiro ano de engenharia de automação e controle.
        Obrigado Cláudio

        1. 0

          Olá Rony!

          Realmente, é díficil achar matéria sobre este tipo de circuito integrado e seu funcionamento. Mas encontrei no site da Holtek um flowchart com os passos para realizar a decodificação ( note application HA0120E e HA0121E). Encontra-se no link : http://www.holtek.com.tw/english/tech/appnote/uc/pdf/ha0120ev110.pdf .Também alguns colegas postaram maneiras diferentes de realizar a decodificação. Por exemplo: O projeto enviado por José Ney no link http://blog.larios.tecnologia.ws/iBlog/archives/1899/. Também no site ASM51 poderá ler a matéria do colega Fabim no link http://www.asm51.com.br/phpbb/viewtopic.php?f=10&t=7322.
          Também poderá baixar o pdf no link http://application-notes.digchip.com/044/44-34036.pdf mostrando o protocolo.
          Quando você diz ‘acionar uma variável’, o que você quer dizer? Colocar um valor nela? Incrementa-la? Decrementa-la? Uma variável de quantos bits? Se puder ser mais específico do que você pretende fazer fica mais fácil entender.
          Cláudio

          1. 0

            Ok, eu preciso apertar o botão de gravação, depois apertar o botão do controle para gravar(exemplo botão 1).
            Depois de gravado, quero somente acionar uma saída do pic (exemplo: Botão 1 do controle acionado, “output_high(pin_a5)), simples assim, com esse código, consigo entender como foi feita a leitura do ht6p20b, sua gravação na eeprom, e depois a comparação para acionamento da saída . Desculpa se não estou conseguindo me expressar corretamente.

            Obrigado Cláudio

        1. 0

          Cláudio, Boa noite, consegui adaptar seu código pra minha necessidade, muito bom, só não estou conseguindo resolver um probleminha, talvez possa me ajudar.
          O código depois de adaptado, funciona certinho, aciono o botão 1, conta um determinado tempo (+ ou – 30s) e para, se eu acionar enquanto está contando o tempo, ele interrompe a contagem, tudo certo.Porém se eu ficar com o botão apertado ele fica alternando liga e desliga.
          Não consegui entender 100% a parte de gravação pra eu colocar algo pra evitar isso.

          Se fosse no caso de entrada de botão, normalmente uso o seguinte:

          //////////////////////////////////////////////////////
          if (input(pin_b4)){
          delay_ms(10);
          x++;
          do{}
          while(input(pin_b4));
          }
          /////////////////////////////////////////

          Segue o código que está funcioando, porém com esse detalhe.

          Obrigado.

          ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          ////////////////////////////////////////////////////////////////////////////////
          ///////////*************************************************************////////
          //**************************************************************************////
          /////////////////Claudio Lários////////////////////////////////////////////
          //****************************************************************************//
          //****************************************************************************//
          //****************************************************************************//
          ////////////////////////////////////////////////////////////////////////////////
          ////////////////////////////////////////////////////////////////////////////////
          //==============================================================================

          #include
          #device adc=8
          #use delay(clock=4000000)
          #ignore_warnings 203,202 //desconsidera mensagem de ‘condition always true’
          #fuses NOWDT,INTRC_IO, NOCPD, NOPROTECT, NOMCLR, NOPUT, BROWNOUT
          #ZERO_RAM
          #use fast_io(a)
          //bytes
          #byte tris=0x85
          #byte gpio=0x05
          //bits
          //bit
          #bit LEDG=0x05.0//led learn pino 7
          #bit LRN=0X05.0//botão de gravação/apagamento pino 7
          #bit RF =0x05.3 //entrada do sinal de RF pino 4
          #bit t0if=0x0b.2//flag over flow timer 0
          //defines
          #define NBIT 28 // numero de bits
          #define apagar 70 //tempo com botão LRN apertado para apagar eeprom
          #define T_MAX 250 //tempo maximo em modo de gravação de controles (15 seg)
          #define T_basico 500 //tempo basico (pulso inicial da transmissão)
          //#define v_tempo_acionado 4000 //tempo das saidas acionadas em modo pulso
          #define t_intervalo 400 // intervalo entre transmissões (400 a 5000)
          #define tris_led 0b001000; //trisio para acender led prog
          #define tris_lrn 0b001001; //trisio para acender led prog

          //variavéis globais
          int32 buffer=0; //buffer de dados a receber
          int32 bufferx=0;//buffer de copia da transmissão anterior

          int16 timerx=0;
          int1 fled1,fled2,fled3;//flags auxiliares
          void testa_lrn(); //prototipo
          int16 cont=0;
          int16 contador=0;
          int16 botoes=0;
          int16 soma=0;

          int16 desl_qd_ap_botao=0;
          int16 cnt_eeprom;

          //==============================================================================
          // Rotina para captura de bits enviados pelo tx (ht6p20b)
          //==============================================================================

          int1 get_htp(void) {
          int8 x=0;
          buffer=0;
          while(!RF){
          testa_lrn();
          if(!++timerx) return false;
          }

          if(timerx>t_intervalo) { // intervalo entre transmissões (23te x pulso basico)

          for(x=0;x>=1;
          }
          else buffer>>=1;

          delay_us(T_basico);

          if(!RF){ return FALSE; }
          }

          return TRUE;
          }

          else return FALSE;
          }
          //==============================================================================
          // Rotina de apagamento dos controles gravados
          //==============================================================================

          void apagar_eeprom(){
          int8 a;
          for(a=0;a<128;a++) { write_eeprom(a,0xff); }
          tris=tris_led;
          for(a=0;aapagar)&&!LRN){ apagar_eeprom();}//apagar todos controles
          tris=tris_led;//saida no pino 7
          if(tempo_led>T_MAX) LEDG=1; //termina periodo de programação e apaga led prog
          }
          //Rony // desliga_saida();//desliga saidas ativadas apos tempo
          }
          //==============================================================================
          // Rotina de pesquisa por controle gravado na eeprom
          //==============================================================================
          int1 procura(){

          int8 a;
          for(a=0;a<127;a+=3){

          if(make8(buffer,2)!=read_eeprom(a)) continue ;//achou o primeiro byte?
          if(make8(buffer,1)!=read_eeprom(a+1))continue ;//achou o segundo byte?
          if(make8(buffer,0)!=read_eeprom(a+2))continue ;//achou o terceiro byte?
          return true;//sim! Os tres!
          }
          return false;//não!
          }

          //==============================================================================
          // Rotina para obter o endereço que deve ser gravado o novo controle
          //==============================================================================

          int8 end_gravar(){
          int8 a;

          for(a=0;a=1){beep2(); } //Chama void beep somente em condição que botoes>=1, ou seja, quando alguma tempo estiver acionado
          desl_qd_ap_botao++;
          cont=0;
          contador=0;
          botoes=3;
          delay_ms(400);// tempo para não contar a variável de baixo muito rápida e conar mais de um

          }//aciona a saída 3 (Botão 3)

          ///3333333333333333333333 **acionamento botão 3** 333333333333333333333333333333333333333333333///////

          //222222222222222222222 **acionamento botão 2** 2222222222222222222222222222222222222222222222222/////
          else{

          if(bit_test(aux,7)) {

          if(botoes==0){beep(); } //Chama void beep somente em condição que botoes=0, ou seja, quando nenhuma tempo estiver acionado
          if(botoes>=1){beep2(); } //Chama void beep somente em condição que botoes>=1, ou seja, quando alguma tempo estiver acionado

          desl_qd_ap_botao++;
          cont=0;
          contador=0;
          botoes=2;
          delay_ms(400);// tempo para não contar a variável de baixo muito rápida e conar mais de um
          } //aciona a saída 1 (Botão 2)
          //222222222222222222222222 **acionamento botão 2** 22222222222222222222222222222222222222222222222////

          ///11111111111111111111111111 **acionamento botão 1** 1111111111111111111111111111111111111111111111///

          if(bit_test(aux,6)){

          if(botoes==0){beep(); } //Chama void beep somente em condição que botoes=0, ou seja, quando nenhuma tempo estiver acionado
          if(botoes>=1){beep2(); } //Chama void beep somente em condição que botoes>=1, ou seja, quando alguma tempo estiver acionado

          desl_qd_ap_botao++;
          cont=0;
          contador=0;
          botoes=1;
          delay_ms(400);// tempo para não contar a variável de baixo muito rápida e conar mais de um

          }//aciona a saída 2 (Botão 1)
          ///11111111111111111111111111111 **Fim do acionamento botão 1** 1111111111111111111111111111111111111////////
          }
          LEDG=1;
          }
          else{
          tris=tris_led;
          if(!LEDG){
          if(!gravar()) { LEDG=1; }//gravação ok, led learn apaga
          Delay_ms(3000); // Tempo para não acionar as saidas logo depois da gravação
          }
          }
          }
          ///////////////////////////////////////////////////////////////////////////////
          ///////////////////////////////////////////////////////////////////////////////
          ///////////////////////////////////////////////////////////////////////////////
          //==============================================================================
          // Rotina de recepção do tx comparando 2 recepções consecutivas
          //==============================================================================

          void recebe_tx(){
          static int1 fr;
          if(get_htp()){
          if(!fr) {bufferx=buffer; fr=1;}//salva a primeira recepção
          else{
          fr=0;
          if(bufferx==buffer){ action(); bufferx=0; }//compara a primeira com a segunda
          }
          }
          }

          //==============================================================================
          // Rotina principal
          //==============================================================================

          void main() {

          setup_adc_ports(NO_ANALOGS|VSS_VDD);
          setup_adc(ADC_OFF);
          setup_counters(RTCC_INTERNAL,RTCC_DIV_256);
          setup_timer_1(T1_DISABLED);
          setup_comparator(NC_NC_NC_NC);
          setup_vref(FALSE);
          tris=tris_led;

          if((!input(pin_a4))) {botoes = 4; desl_qd_ap_botao=1;} // função “desliga_qd_ap_botao foi colocado com valor 1,
          //pois permite desligar a função no primeiro toque de qualquer botão,
          // pois isso acontece quando essa variáve é igual a 2”

          output_low(pin_a0);
          output_low(pin_a2);
          output_low(pin_a5);
          LEDG=1; //mantém led prog apagado quando liga na energia
          //==============================================================================
          // Loop principal
          //==============================================================================

          while(1){

          if(desl_qd_ap_botao>=2){desl_qd_ap_botao=0; cont=0;
          contador=0; botoes=0; soma=0; output_low(pin_a5); } //Desliga saídas se qualquer botão for acionado

          ///11111111111111111111111111111111***Botão1****1111111111111111111111/////////////////////////1

          if(botoes==1 && (input(pin_a4))){

          cont++;

          // if(beep_off==0){beep();} //aciona beep

          if(cont>=10){ contador++; cont=0; }

          if(contador>=1 && contador=1501){ output_low(pin_a5); } // Apaga (botão 2)

          if(contador>=1502) {cont=0; contador=0; soma++; } //Tempo apagado (botão 2)

          if(soma>=1){ botoes=0; soma=0;}

          }
          //////////11111111111111111***Botão1****11111111111111111111111111////////////

          //////////222222222222222222***Botão2****2222222222222222222222222222²²²²²²²²

          if(botoes==2 && (input(pin_a4))){

          cont++;

          // if(beep_off==0){beep();} //aciona beep

          if(cont>=10){ contador++; cont=0; }

          if(contador>=1 && contador=1561){ output_low(pin_a5); } // Apaga (botão 2)

          if(contador>=3102) {cont=0; contador=0; soma++; } //Tempo apagado (botão 2)

          if(soma>=5){ botoes=0; soma=0; }
          }
          ///22222222222222222222***Botão2****2222222222222222//////////////////////////

          ////3333333333333333333***Botão3****33333333333333//////////////////////

          if(botoes==3 && (input(pin_a4))){

          cont++;

          // if(beep_off==0){beep();} //aciona beep

          if(cont>=10){ contador++; cont=0; }

          if(contador>=1 && contador=3103){ output_low(pin_a5); } // Apaga (botão 3)

          if(contador>=6200) {cont=0; contador=0; soma++; } //Tempo apagado (botão 3)

          if(soma>=15){ botoes=0; soma=0; }

          }

          //////33333333333333333333***Botão3****3333333333333333333333////////////////////

          //////////////////////////início Pino aterrado////////////////////////////////

          if((!input(pin_a4)) && botoes>=1){

          cont++;

          if(cont>=10){ contador++; cont=0; }

          if(contador>=1 && contador=3103){ output_low(pin_a5); }

          if(contador>=6200) {cont=0; contador=0; }

          }

          ///////////////////////Fim Pino aterrado////////////////////////////////

          recebe_tx();//verifica se houve uma recepção de tx
          testa_lrn(); //verifica se foi pressionado botão de aprendizado
          }//while(1)
          }//main
          ///////////////////////////////////////////////////
          /////////////////////////////////////////////////////

          1. 0

            Olá RonyFreitas!
            Para testar um botão, se ele continua apertado e aguardar soltar, corretamente pode

            usar o código que você citou:

            //////////////////////////////////////////////////////
            if (input(pin_b4)){
            delay_ms(10);
            x++;
            do{}
            while(input(pin_b4));
            }
            /////////////////////////////////////////

            Mas no caso da recepção é mais complexo, porque o processo da recepção bem sucedida poderá envolver no mínimo dois frames transmitidos (uns 150 mseg). Poderá ser mais, se houver muita interferência no local (quando demora para acionar).
            Para identificar se um botão do tx continua apertado, tenho usado um (ou mais) temporizador ‘dinamico’, colocado para decrementar continuamente dentro do loop da rotina principal, sendo carregado em cada recepção bem sucedida. Quando não há recepções bem sucedidas, ele chega a zero, reseta um flag de trava (de bloqueio). Este é usado na rotina que testa o bit correspondente ao botão acionado no tx e faz um ‘and’ com este flag ‘trava’. No primeiro acionamento do botão, a rotina também deverá setar este flag, para impedir novo acionamento da rotina para o botão apertado. E em cada recepção bem sucedida, deverá ocorrer uma nova carga no temporizador ‘dinamico’.
            Enquanto houver recepção bem sucedida, o temporizador dinamico nunca chega a zero e portanto, nunca reseta o flag trava, sendo que ele impede de acionar várias vezes (alternando). Mas se depois de um tempo aproximado a 6 a 10 recepções não receber carga por não ter havido recepção do tx, então o flag trava será resetado, liberando para uma possivel nova recepção.
            O ideal é um contador dinamico mais um flag trava para cada botão, para serem independentes uns dos outros, apesar que em certas aplicações apenas um de cada pode ser aceitável.

            Resumindo:
            1) Use um (ou mais) contador no loop principal decrementando até zero

            int16 cont_din;

            while(1) {//LOOP PRINCIPAL

            if(cont_din)cont_din–;
            if(!cont_din) trava=0;

            }//while(1)

            Na rotina de teste:

            if(botoes && !trava) {
            aciona();
            trava=1; //bloqueia até soltar botão no tx por um tempo
            }

            Creio que é meio complexo para entender de ínicio, mas no fim fica fácil.
            Acredito que possa existir outras soluções empregadas pelos programadores profissionais, mas desconheço, porque aindo sou apenas um hobista nesta área, tenho muito que aprender.
            Não tenho condições de alterar e testar o seu código, pois teria que ter a rotina completa e tempo para isto, coisa que ultimamente não estou tendo nem para novos artigos.

            Cláudio

  6. 0

    Bom dia Claudio. Obrigado por responder. Eu estou usando um tx da Vseg, e também da jfl, que usa o HT6P20B. Eu passei o osciloscópio na saida do tx, e é possível perceber muitas interferências, mas o que me chamou a atenção, é que somente a saida do pino 5 do pic 12f675 que é acionada. As outras duas não acionou nenhuma vez.

    Gilmar

    1. 0

      Olá Gralves!
      Como você está usando? Gravou um pic com o hex original cujas saídas acionam outro pic? Fez alguma alteração na rotina? Tentou gravar um controle por vez e testar? Pode ter um vizinho com um mesmo numero de controle (remoto mas possível).
      Claudio

      1. 0

        Olá Claudio. Os pinos do pic12f675 onde esta o programa do receptor, estão ligado aos pinos de um pic16f628, com um resistor de 10k ao gnd. Eu já fiz isso, gravei botão, por botão para fazer o teste, mas o pino 5 do 675 exita a entrada do 628 com um pulso muito rápido. Eu fiz uma mudança no meu programa, colocando um retardo de 500ms na entrada que esta recebendo esse sinal, para ver se resolve. Ou seja, esta saída só vai ser aciona, se o botão do canal 3 for pressionado pro mais de 500ms. Vou ver se resolve. Não foi possível testar ainda, porque não terminei de montar outra placa. Amanha cedo vou levar o pic gravado e substituir, para fazer o teste no local que esta instalado o sistema.

        1. 0

          Olá Gralves!
          Você colocou um capacitor de 220 nanofarads do vcc ao gnd bem próximo de cada pino dos pics? Evita ‘resets’ indesejados por interferência mutua entre pics. Você usou retenção ou pulso? Invertido ou normal? Quanto tempo você acredita que seja este ‘pulso’ no pino 5? Como se fosse acionado o tx em modo pulso e soltado o botão? Ou é bem mais rápido? Você compilou o arquivo c para ht6p20b? Ajustou as configurações de usuário? Existe algum rele que seja acionado que você tenha esquecido de colocar um diodo em paralelo com sua bobina? Pode ser qualquer bobina que seja ligada sem este diodo? Ao se desligar uma bobina, ela gerará elevada ddp entre os seus terminais, que podem resetar pics com facilidade, com o perigo de destruir o chip. Mas parece que você disse que ligou apenas um diodo para teste sem o restante do circuito, é isto? Se for, não deve ser o caso. Creio que você fez o teste fora do veículo, na bancada. Também manifestou o problema? Ou somente no veiculo? A energia do carro (12 volts) é muito poluída eletricamente falando, com ruídos de faíscas, alternador, componentes eletrônicos, etc. Atenção especial deve ser dado na entrada da fonte quando usada em veículos.

          Att.
          Cláudio

          1. 0

            Oi Claudio, sim, eu coloco capacitor de 100nf entre os pinos + e gnd. Eu estou usando pulso normal. Como eu havia dito, eu coloquei no meu programa um retardo de 500ms, como se fosse um antrebut, mas ainda esta ocorrendo o problema somente no píno 5. Eu compilei o seu programa C para o ht6p20b. Na configuração de usuário, eu descomentei para uso do 675. O programa esta rodando blz, a não ser esse ativação da saída -s2 – pino 5. O tempo desse pulso é maior que 500ms, porque o retardo que coloquei no meu programa indica isso, pois ainda esta abrindo a tranca magnética da porta. Se me passar um e-mail, eu lhe mando o projeto inteiro pra você analisar. Esse projeto é para controlar 3 portas com tranca magnética. Se enviar um sinal para abrir uma, as outras fica travada. E se uma abrir, as outras não abre, e assim sucessivamente. O programa sinaliza a abertura da porta através de LDs VD e VM. O LD verde pisca na cadencia de 1/2 segundo, se um dos botôes do tx for acionado, e se abrir a porta, ele pisca de 1 em 1 segundo. A trava elétrica volta a energizar depois de 10s. Se não tiver funcionando correto, as portas não funcionara.

          2. 0

            Relacionado com os diodos em paralelo com as bobina, é necessário coloca-los, para não queimar o transistor por pico reverso. Como eu havia lhe dito antes; eu estou com o receptor montado no protoboard. Somente um regulador filtrado com os capacitores, o pic12f675, os resistores e o LDs nos pinos, para visualizar o funcionamento. E de vez em quando, o LED na saída do pino 5 aciona. Lá no local onde montei o projeto completo, o acimamento é mais frequente, devido a muitos sistemas sem fio instalado. As interferência são mais frequente. Aqui na minha oficina de eletrônica, tenho poucas interferências, por isso aciona com uma frequência menor.

          3. 0

            OLÁ GRAVES!
            Vamos tentar no arquivo c. Experimente reduzir a janela de recepção alterando a constante para ht6p20b nomeada de tmax_ht=80 para 20 ou 30. Recompile e teste o novo hex. Verifique se pode reduzir alguma oscilação do receptor rf_ colocando um resistir de 1M5 a 2M2_ na saída analógica. Fico no aguardo.
            Claudio

          4. 0

            Olá Claudio, boa noite. Eu fiz a mudança. Estou com o osciloscópio plugado na saída analógica do rx. Foi na linha 201(byte const tmax_ht= 20;). Primeiro eu tentei com 30, mas logo que liguei, o led do pino 5 acendeu umas três vezes, depois pus esse valor (20). Passou uns 10 minutos e houve mais um lampejo do led. De vez em quanto eu leu um trem de pulso no osciloscópio. Mas não da para ver quando exita o led.

          5. 0

            Olá Gralves!
            Mantenha a janela (constante tmax_ht=20) e altere a seguinte linha da rotina de recepção do ht6p20b:
            if(lc>tmax_ht) {reset_rx (); qb=24;}
            por:
            if((lc>tmax_ht)||(hc>tmax_ht)) {reset_rx (); qb=24;}

            Também vamos apertar a escolha do bit 1 ou 0 na rotina, trocando a linha :
            else { shift_right(&buffer[0],3,(lc>hc)) ;
            por:
            else { shift_right(&buffer[0],3,(lc>(hc+(hc/2)))) ;
            Depois recompile e teste o novo hex.
            Fico no aguardo
            Att.
            Claudio

          6. 0

            Oi Cládio, boa noite, eu fiz as alterações, conforme me explicou. As mudanças foram feitas nas linha 755 e 756, ROTINA DE RECEPÇÃO DOS 24 BITS.
            A compilação ocorreu normal, sem erros, mas eu não consegui gravar os TXs.

          7. 0

            Claudio, durante a gravação do pic, eu percebi que o checksum no Pickt 2 não alterava. Resolvi reiniciar o PCW, para ver se alterava. Puxei o programa que esta funcionando antes,com o problema fiz o teste, e funcionou. Fiz novamente a primeira alteração na linha 755, o comando (if), gravei o pic só com essa linha primeiro. O checksum mudou, não era o mesmo. Coloquei o pic no protoboard e o LD lampejou novamente. Ou seja eu consegui gravar o controle. Alterei a segunda linha, a 756 com a instrução (else). Gravei o pic e consegui gravar o TX. Durante a edição desse texto eu não vi o LD acender.Estou com o osciloscópio plugado na saída do RX para ver se algum ruido vai aparecer e ocorrer o problema. Estou confiante que funcionara. Eu lhe informo depois.

          8. 0

            Oi Claudio, nesse momento, em quanto eu estava observando o sinal no osciloscópio, o LD que esta no pino 5, acendeu novamente. O receptor, recebe ruidos constantes, não uma forma de onda gerado pelo ht6p20b. Mesmo assim ocorre esse acionamento. Hoje eu mudei meu programa, e aumentei o retardo na entrada do sinal desse pino, para 1000ms. Durante o dia inteiro, a tranca magnética não foi acionada, mesmo com esse pulso do pic12f675. Tudo indica que o pulso é menor que 1000ms. Não quero lhe dar trabalho, mas se você tiver mais alguma informação, quando tiver um tempo, eu agradeço.

          9. 0

            Olá Gralves!
            Onde tenho feito as montagens não tem tanto ruido elétrico na faixa de 433mhz e fica difícil simular a sua situação. Mas irei estudar mais alguma possibilidade para ajudar a tentar contornar a situação.
            Cláudio

          10. 0

            Ola´Claudio, como vai, tudo bem. Eu gostaria de lhe passar uma informação, sobre aquele problema que estava ocorrendo, do acionamento do pino 5 do PIC12f675 do seu projeto acima. Você havia me passado algumas instruções para tentar corrigir o problema, alterando primeiramente o valor da instrução,tmax_ht=80, para 20, ou 30. Eu fiz isso mas a saída anida continuava a ser exitada.

            Uma coisa que não lhe falei, foi que ao alimentar o projeto que esta montado no proto board, essa saída também era exitada. Ai de tempo em tempo ela era exitada. No entanto um dia desses eu resolvi, sem conhecimento algum, colocar na instrução tmax_ht=40 e fiz o teste de alimentar o protoboard para ver se a saída do pino 5 seria exitada. Para minha surpresa ela não foi mais. Deixei o projeto energizado e percebi que esse pino 5 onde estava com um LED nele, não mais foi exitado por ruido externo. Estou lhe passando essas informações, para quando tiver tempo descobrir, por que com esse valor esse problema não ocorre mais.

          11. 0

            Olá Gralves!
            Obrigado por notificar suas descobertas curiosas! Quando tiver um tempo, irei analisar mais de perto o assunto. Mas, espero que isto tenha resolvido o seu problema na questão da interferência.
            Cláudio

  7. 0

    Olá Claudio, com esta, tudo bem?. Claudio eu fiz um projeto de controlador de intertravamento de portas, feito em ladder, usando seu projeto do receptor,O RX_GEN_FLEX_C para utilizar um tx. Nesse projeto eu utilizo os três botoes do tx independente. Foi um dos motivos que eu o achei interessante. Eu percebi recentemente que umas das portas esta abrindo sozinha, ou seja, sem pressionar o potão do controle. Montei no protoboard para ver se era algum bug no programa, visto que limpei varias vezes a memoria e gravei os controlos de novo, e o problema continuou. Esta ocorrendo um acimamento no pino 5. Os dois outros esta perfeito. No teste com o projeto montado no protoborad, eu coloquei um led azul para me chamar atenção, quando o problema ocorresse.De vez em quando, ele da uma piscada. Como eu disse, isso só ocorre no pino 5. Eu dei uma olhada no seu código fonte para ver se via alguma coisa que pudesse fazer, para corrigir esse problema, mas eu só arranho no C. Por isso estou precisando de sua ajuda, pra saber o posso fazer para corrigir esse problema.

    1. 0

      Olá Graves!
      Pode acontecer em locais com muita interferência em 433mhz que possa ocorrer acionamento esporádico pelo receptor em especial se esta interferência for cíclica ou que se repita em uma determinada sequência. Também, notei que alguns receptores comerciais de 433mhz tendem a entrar em oscilação em dados momentos , gerando ruído cíclico. Alguns receptores tem uma saída analógica aonde podemos colocar um resistir de 1M5 deste pino ao gnd. Em alguns casos tem resolvido. Em outros tem que trocar a frequência de trabalho optando por tx de 315mhz e receptor da mesma frequência. Se dispor de um osciloscópio, tente ver o sinal na saída do receptor para ver como é a situação de interferência de sua região. A propósito, qual é o modelo de tx que está usando? Http?

      Claudio
      Claudio

  8. 0

    Boa noite Sr. Cláudio. Como estão as coisas? Estou com uma dúvida. Tentei compilar seu código em C utilizando um PIC18F4550 e não consegui fazê-lo funcionar. Você poderia me dar alguma dica. Utilizei os mesmos pinos que estão no código atual, alterando apenas o tipo do microcontrolador. O módulo é o HT6P20B. Desde já agradeço. Um abraço.

    1. 0

      Olá Xuguinho!
      Quando migramos de um modelo de pic para outro, sempre temos que analisar a compatibilidade entre eles.
      Por ex. Temos um programa para o 12f629. Queremos migrar a 12f675. Então mudamos o programa somente trocando o arquivo ‘include’ para o mesmo. Não vai funcionar! O 12f675 tem conversor analógico/digital que toma conta dos pinos ao resetar. Temos que incluir linhas de código para desligar o conversor analógico/digital ao reiniciar o programa. Neste caso, temos poucas alterações.
      E se temos outra familia, por exemplo do 12 para o 18? Piorou mais ainda! Temos que analisar o datasheet do pic que migraremos e ver esta compatibilidade, é quais alterações terão que ser feitas. Se forem muitas, talvez seja melhor fazer um programa novo partindo do zero, para aquele modelo.
      Em resumo: Migrar um programa de um pic para outro não se trata apenas de trocar os arquivos ‘include’ e ir compilando. Somente se forem compatíveis este método irá funcionar!
      Portanto, estude o datasheet do pic18f4550 e veja o que é diferente, para alterar nas linhas de código.
      Cláudio

  9. 0

    Oi Claudio estou aguardando sua ajuda no seu projeto do receptor flex em, que achei muito legal, devido às opções de varios tx. Eu comecei aprender o assembler ja algum tempo, comecei recentemente aprender um pouco de C para Arduino, mas eu só arranho. Eu aprendi um poucos mais de ladder, devido a precisar na empresa que trabalhei muitos anos. Mas eu gosto muito do assembley, mas não tive muito tempo para me dedicar no aprimoramento dela. Inclusive baixei quase todos os programas seus programa tentar me aprimorar mais. Mas o que eu gostaria de saber também, é se você dispõe de um curso e material didático de assembley que eu poderia adquiri-lo para meu aprimoramento. Tenho algumas apostilas, mas esse material é muito tecnico, embora eu seja técnico em eletrônica, eu gostaria de material mais detalhado. Ou seja, mais fácil de assimilar.

    1. 0

      Olá Gralves!
      Fiz a montagem no protoboard e defini para ht6p20b, pulso, pic 12f675, aprender individual, saida normal, e compilei gerando o hex.
      Testei com varios controles e funcionou normalmente. Gravei um botão de um controle e depois o outro e também com os 2 botões acionados (o terceiro botão de alguns controles). Também repeti com outro controle e todos estão funcionando normalmente depois do aprendizado. Deve haver algum erro na sua compilação ou na montagem.
      Eu não tenho curso ou mesmo artigos específicos sobre a linguagem ‘assembly’ que possa ser de ajuda. Poderá pesquisar na internet que temos uma fartura de material. O youtube tem muitos cursos que poderão ser de ajuda. Para compreender programas em C, poderá usar o arquivo .List para ter uma ideia de como o programa foi montado. Obtenha clicando aqui estes arquivos para você testar.
      Cláudio

      1. 0

        Boa noite Claudio. Obrigado pelo retorno. Eu fiz o teste com quatro TX. Os quatros deles usam um o HT6P20B. Dois usam um oscilador 433, ajustado com trimmer. Os outros dois usam um oscilador R980 para gerar a portadora 433. Mas eu consegui inicialmente com um da VSEG que usa o R980, e o outro ja JFL que usa esse oscilador eu no consegui. Passei o osciloscopio no da jfl, que uso muito para centrais de alarme para ver se conceguia descobrir o problema, não consegui ainda. Vou usar o da VSEG que ficou blz.

        1. 0

          Olá Gralves! Eu não conheço estes controles, mas sei que o Ht6p20b tem um resistor e um capacitor para escolher uma dada frequência de trabalho. Verifique se são diferentes nestes controles.
          Cláudio

  10. 0

    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.

    1. 0

      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

      1. 0

        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.

  11. 0

    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!!!!!

    1. 0

      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

  12. 0

    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

    1. 0

      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

    2. 0

      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

  13. 0

    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.

    1. 0

      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

      1. 0

        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.

  14. 0

    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.

    1. 0

      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

  15. 0

    Boa noite Cláudio. Entendi o funcionamento de gravação e leitura. Fiz no proteus! Você é o cara. Tenho outra dúvida sobre a variável botoes, que aparece assim em seu código como: botoes=buffer[2]; Queria entender o seguinte: Suponha que pressionei um botão do controle chaveirinho e o mesmo enviou a string: C6F06D. Nesse caso, o valor do buffer[2] terá qual valor da string que foi recebida pelo controle? Seria o caractere ‘C’ em binário (1100)? Um abraço.

  16. 0

    Nobre Lário, tudo bem?
    Queria tirar mais uma dúvida contigo. Para que serve o comando shift_right(&buffer[0],3,(lc>hc)); Ele rotaciona os bits? Preciso salvar na eeprom, 1 byte antes do sinal do botão e depois ler o valor. Um agrande abraço.

    1. 0

      Olá Xuguinho!
      Este comando rotaciona para direita, ‘0’ ou ‘1’, dependendo se ‘lc’ for maior ou menor que ‘hc’. Para salvar um byte pode usar o comando write_eeprom( endereço, byte desejado) e para ler use read_eeprom(endereço).
      Cláudio

  17. 0

    Olá Lário. Entendi sua explicação. Ficou bem claro. Experimento: Fiz alguns testes com um controle de 4 botões no padrão HT6P20B. O mesmo repete os últimos bit para os botões 3 e 4. Veja como ficou a leitura de cada botão: botão_1 = 8B6976, botão_2 = 4B6976, botão_3 = 2B6976 e botão_4 = 1B6976. Os botões 3 e 4 acionam as mesmas saídas. veja como ficou o byte de cada botão: botão_3 = 0010 e botão_4 = 0001. Logo temos dois ‘zeros’ nos bits 6 e 7. Consegui resolver isso acrescentando mais um bit (bit 5) na condição IF que estava na dúvida na postagem anterior. Assim, os botões acionaram saídas diferente, pois a lógica comparou 3 bits (001 e 000) ao invés de dois. Você é o cara!!! Outra dúvida: Teria como escolher qual saída poderei acionar ao pressionar um botão? Ex: Se quisesse acionar a saída 4 com o botão 1, ou acionar a saída 4 com o botão 2? Pensei em acrescentar um dip switch para selecionar a saída que quisesse acionar com um botão pressionado. Assim a configuração ficaria gravado na eeprom. Pensei em gravar um número na frete ou no final do código que será gravado na eeprom. Ex: Ao colocar a chave 1 do dip switch na posição ON e pressionar o botão aprender_botão, gravaria a posição da chave mais o código do botão (14B6976). E assim por diante: 24B6976, 34B6976. Um abraço e muito obrigado por compartilhar o conhecimento. 😀

    1. 0

      Olá Xuguinho! Com respeito a sua dúvida, pelo que você passou é realmente possível acrescentar uma chave dip, desde que você a acione na ocasião do aprendizado do controle, e fazendo o aprendizado botão por botão. Deverá salvar cada botão não em 3 bytes, mas em 4 bytes (um byte para dizer ‘qual’ canal acionar). A rotina de recepção tem que ser alterada para buscar apenas o endereço do chaveirinho e desprezar o byte de ‘canal’, na hora de comparar mas usa-lo na hora de acionar. Sucesso em seus experimentos!!!
      Cláudio

  18. 0

    Olá mestre Lário, tudo bem? Andei estudando um pouco sua obra prima e tive a idéia de tentar traduzir o sinal que é enviado ao módulo ao pressionar um botão. Começei com um controle tipo chaverinho, padrão HT6P20B. Ao pressionar o primeiro botão, recebi no terminal o código C6F06D, sendo o primeiro byte igual a 1100. Ao pressionar o segundo botão, recebi o código 46F06D com o primeiro byte igual a 0100. Por fim, o terceiro botão 86F06D com o primeiro byte igual a 1000. Até aí entendi. No exemplo citado, as saídas ligam quando: A saida_1 = 11, a saida_2 = 01 e a saida 3 = 10. Uma coisa que fiquei na dúvida foi entender para que serve o bit_test(botoes,7))||(bit_test(botoes,6))). A variável ‘botoes’ recebe algum valor do buffer ou sbuffer? Caso sim, quais? O número 6 e 7 representam algum binário do primeiro byte? Para quê eles servem exatamente? Pretendo utilizar um pic16f268a para experimentos e ampliar o número de saídas. Desde já agradeço e um grande abraço.

    1. 0

      Olá Xuguinho! Por favor, sem essa de ‘mestre’. Sou apenas um hobista de microcontrolador!!! Quanto a seu raciocínio, ele está correto. A variável ‘botões’ apenas armazena o ultimo byte recebido (buffer[2]), para realizar os testes sobre o estado dos botões, sendo estes os bits 6 e 7. Poderia ter sido feito este teste usando o próprio buffer, mas na rotina de recepção tem a opção ‘aprender todos os botões’ ou ‘aprender único botão’. Quando uso ‘aprender todos os botões eu simplesmente apago estes 2 bits (6 e 7) e gravo na eeprom. Então, tenho que salva-los, para teste posterior, do estado dos botões. Por isso que salvo na variável ‘botões’.
      Não sei se deu para entender.
      Cláudio

  19. 0

    Olá Lario. Entendi o que você quis dizer. Pintou uma dúvida ❓ :
    Na condição -> if((bit_test(botoes,7))||(!bit_test(botoes,6))), os bits 6 e 7 se referem à algum valor hexadecimal do código enviado pelo controle (chaveirinho HT6P20B) quando pressionarmos um botão? Ex:F573498

    Um abraço.

    1. 0

      Olá Xuguinho!
      Exatamente! Os bits 6 e 7 se referem ao terceiro byte recebido em uma transmissão do protocolo ht6p, sendo os botões esquerdo e direito do controle remoto (”1″ = acionado).
      No seu exemplo seria o ‘F’ que em binario = ‘1111’. Os botões seriam os 2 primeiros ‘1’. Os outros 2 bits fazem parte do endereço fixo do controle (22 bits de endereço fixo.
      Cláudio

  20. 0

    Olá Lário tudo bem? Você é uma bênção. Esse blog tem projetos que são muito além de materiais didáticos. Mais uma vez agradecido por compartilhar seu conhecimento. Antes de mais nada, gostaria de tirar uma dúvida contigo.Como faria para gravar mais de um botão do mesmo controle chaveirinho na memória para ligar o mesmo relé na linguagem C? Por exemplo. Quero utilizar dois botões do controle para ligar o relé 01. Desde já agradeço. Um abraço.

    1. 0

      Olá Xuguinho! Obrigado por seu comentário apreciativo pelas matérias deste blog. Para fazer o que você deseja terá que mudar a lógica de acionamento no próprio código ‘C’.
      Observe a porção de código, para exemplo, referente a recepção do Ht6p20b abaixo:

      #ifdef CHIP_HT6P20B
      #ifndef s2_ret
      #ifdef s2_invertido
      if((bit_test(botoes,6))&&(bit_test(botoes,7))) _s2=0; else _s2=1;// pino 5 ‘0’ // Note que aqui precisa estar os 2 botões acionados para acionar a saida s2 pino 5 (lógica and &&)
      #else
      if((bit_test(botoes,6))&&(bit_test(botoes,7))) _s2=1; else _s2=0;// pino 5 ‘1’ //idem para opção normal (sem inverter)
      #endif
      #endif

      #ifndef s0_ret
      #ifdef s0_invertido
      if((bit_test(botoes,7))&&(!bit_test(botoes,6)))_s0=0; else _s0=1;// pino 2 ‘0’ // aqui exige que bit 7 seja ‘1’ e bit 6 seja ‘0’ para ligar saída S0.
      #else
      if((bit_test(botoes,7))&&(!bit_test(botoes,6)))_s0=1; else _s0=0;// pino 2 ‘1’ //idem sem inversão
      #endif
      #endif

      #ifndef s1_ret
      #ifdef s1_invertido
      if((bit_test(botoes,6))&&(!bit_test(botoes,7)))_s1=0; else _s1=1;// pino 3 ‘0’ // aqui exige que bit 6 seja ‘1’ e bit 7 seja ‘0’ para ligar saída S1.
      #else
      if((bit_test(botoes,6))&&(!bit_test(botoes,7)))_s1=1; else _s1=0;// pino 3 ‘1’ // idem sem inversão
      #endif
      #endif
      #endif

      Você poderá alterar a lógica acima, para o chip que irá usar, reescrevendo código conforme necessitar acionar uma saída ou mais ao mesmo tempo e com quais botões:
      Por ex.
      if((bit_test(botoes,7))||(!bit_test(botoes,6)))_s0=1; else _s0=0;// pino 2 ‘1’ // se bit 7 ou 6 for ‘1’, acione a saída ‘S0 ‘

      Ou com mais de uma saída:
      if((bit_test(botoes,7))||(!bit_test(botoes,6))){_s0=1;_s2; }else {_s0=0;_s2;}// pino 2 ‘1’ // se bit 7 ou 6 for ‘1’, acione a saída ‘S0 ‘ e ‘S2’

      Fique atento que o código faz uso de funções como ‘inverter saída’, ‘modo pulso/retenção’ . Assim, tem que acertar as modificações em várias partes do programa, como na inicialização, no modo retenção, no modo pulso,etc , para que tudo fique a contento. Dá um pequena ‘embaralhada’ na cabeça, mas é bom para treinar nossos neurônios ‘sobreviventes’ ( ‘tico e teco’).
      Cláudio

  21. 0

    lario estou aqui novamente aproveitando minha folguinha.
    eu montei este receptor generico que na verdade é uma joia,mais estou tendo uns problemas com extra_ terrestre,pois os mesmos estão invadindo meu receptor e desativando rsrsr não sei se voce entende étê e poderá me ajudar proteger destes invasores penetras?.note ai, quando o relé sem hora marcada ele desliga, testei por varias vezes, e por ultimo ativei o relé e desliguei a saida entre o receptor e o pic dai não ele não desliga tem alguma explicaçao para este paranormal?rsrsr estou usando protocolo ht6p20b

    1. 0

      Olá José Luiz! Experimente usar um outro controle remoto( chaveirinho) diferente para teste. Tem um vizinho de um amigo que seu portão acionava quando outro vizinho acionava seu controle remoto. Pode ser que alguém tenha um código parecido nas vizinhanças.
      Cláudio

  22. 0

    lario tudo bem? lario eu montei este receptor para apenas uma saida pelo qual está funcionando muito bem
    no modo htp620b é muito versatil,so tenho uma pequena duvida,exemplo meu controle chaveirinho e de 2 botoes
    e apenas 1 aprende o codigo ou seja apenas um botão funciona.será que estou tendo engano,ou erro? pode me dar uma luz?obrigado

  23. 0

    Olá Claudio!
    Desejo felicidade para você.Já agora para todo mundo,também.
    Este projeto é muito interessante.
    Resolvi montá-lo,em placa de ensaios.
    Mas o meu programador,fabrico caseiro,não deteta o pic 12f675,uso o winpic800. O programador parece-me bem, já experimentei com os pics 16f84A, 16f628A, 16f676, 16f877A. Todos estes foram detetados e seguidamente foram programados com sucesso em outros projetos,obviamente; alguns de sua autoria.
    Mesmo assim tentei programar o pic 12f675, dá o seguinte erro:
    Erro ao escrever no endereço 0x000000 escrito: 0x3000 Lido:0x3FFF.
    Descomentei: #define PERDI_BYTE_CALIBRAÇÂO. tentei novamente, seguinte erro:
    O valor OSCALL do Pic é… 0x3FFF Deseja utilizar o valor do buffer 0x34FC. Em qualquer opção, sim ou não, dá o erro acima citado, o primeiro erro.

    Defeito, Será o programador ou o pic? Ou do utilizador? 😀
    Se o claudio poder dar uma dica, ou seja, dizer de sua sabedoria!. Desde já muito obrigado.
    Grato.
    Costa.

    1. 0

      Olá Costa!
      Eu acredito que está acontecendo o seguinte: Como o pino do ‘MCLR’ está sendo usado como entrada, após a programação, quando se tenta ler o pic irá indicar apenas 0x3ff em todos os endereços. Porque?
      Porque a comunicação com o pic necessita de haver ‘reset’ em dados momentos. Sem o pino ‘MCLR’ atuando, não haverá reset. Pronto! Não se consegue ler mais nada e nem sequer identificar o pic. Parece até que ele queimou! Como resolver o problema? Para resolver isto, o único jeito de resetar o pic sem o ‘MCLR’ é desligando a alimentação do pic. Então, somente nesta situação, terá que usar um esquema diferente de simples programador. Estou postando junto ao artigo original, mais 2 versões com este recurso: Um usa mais 2 transistores comuns (npn e pnp) e a outra, apenas um irf640 ou equivalente. Experimente montar uma destas versões no protoboard e testar. Se tiver já feito o simples programador (com placa e tudo), a versão com mosfet fica mais fácil de adaptar.
      Claudio

      1. 0

        Olá Claudio.
        Muito obrigado por me responder.

        O meu programador já tem essa função, é o Tait,porta paralela.

        Vou adquirir o material necessário e montar novo programador. Mas, terá que ser outro esquema,pois, o meu PC não tem porta serial,DB9. -Tenho gravado os Pics através da porta paralela, DB25.
        Vou tentar resolver o problema.
        Dar-lhe-ei notícias se tal acontecer.

        Bem haja!

        Costa.

        1. 0

          Olá Claudio!

          A minha dificuldade em gravar o PIC 12F675 finalmente foi superada.
          Instalei 2 portas serial -COM- no meu PC e com o novo programador,pic gravado, pronto! Dá uma trabalheira para quem pouco, ou quase nada, percebe do assunto. Mas,a meu ritmo, vou evoluindo,desde que comecei a visitar o seu blog.
          Por tudo o que tenho aprendido aqui, muito obrigado!
          Grato.

          Costa.

          1. 0

            Olá Costa! Parabéns! É isto mesmo! Seja persistente para conseguir seus objetivos. Obrigado por retornar suas expressões sinceras.
            Cláudio

  24. 0

    Olá Cláudio, e a TODOS que estão lendo! Um feedback IMPORTANTE! Depois de muitos testes e perguntas ao autor, descobrimos um problema surreal que muitos podem estar enfrentando: O COMPILADOR! Mudamos a versão do compilador para uma mais antiga e ele resolveu funcionar! Utilizava-mos a 4.2 e mudamos para a que o Cláudio utiliza: 3.2. Funcionou perfeitamente. Se mais alguem tiver esse problema, espero ter contribuido! Um abraço a todos

    1. 0

      Olá Ronantussi!
      Obrigado pela dica. Algo me intriga: Que tipo de código de erro você estava recebendo do compilador?
      Cláudio

      1. 0

        Olá Cláudio. Na realidade não aparecia nenhum erro. Simplesmente não funcionava. Meu sócio que descobriu isso ao longo de anos de experiência. COmplicado não?

        1. 0

          Olá Ronantussi!
          Obrigado pelo retorno. É este tipo de coisa que desanima muitos iniciantes na arte de programação. Fazer o que! Mas nada que uma ‘boa persistência e boa dose de paciência’ não resolva.
          Cláudio

  25. 0

    Ola,,gostaria de testar o controle HT6P20B apenas para acender e apagar um LED. O que deveria ser acrescentado na rotina para isso??

    1. 0

      Olá Ronantussi!
      Você deverá primeiramente recompilar o arquivo “C’ com um compilador CCS, mas alterando a opção de ci conforme abaixo:

      //==============================================================================
      //ESCOLHA O TIPO DE CI DO TRANSMISSOR:
      // O transmissor poderá ter qualquer dos integrados abaixo:
      // PT2240B / PT2262 / HT6P20B
      //Descomente o CHIP desejado e comente os outros usando ‘//’.

      #DEFINE CHIP_PT2240B
      // #DEFINE CHIP_PT2262
      // #DEFINE CHIP_HT6P20B
      // #DEFINE CHIP_HCS

      Escolha também se será modo pulso ou retenção e ainda se será saídas normais ou invertidas, conforme explicação no próprio texto do programa ‘C’.

      Depois, deverá usar o HEX obtido na compilação para carregar o PIC. Desta forma, conseguirá receber a transmissão do ht6p20b.
      O próximo passo será escolher o primeiro circuito e montar (para uma unica saída). No pino 6 ligue apenas um resistor de 470 ohms e o led ao gnd.
      Com o circuito montado e alimentado, realize o aprendizado do tx docontrole, seguindo as instruções do artigo.
      Você terá então um led acendendo e apagando conforme apertar o tx.
      Divirta-se!!!
      Cláudio

      1. 0

        Olá Claudio,,,Entendi o procedimento. Mas devo DESCOMENTAR o HT certo? ali vc descomentou o outro…Outra coisa, estou usando um PIC 16F1827. Muda muita coisa? Não esta dando certo o firmware, talvez por algum setup dele. Como devo proceder??

        1. 0

          Olá Ronantussi!
          Sim, você deverá descomentar o HT e deixar comentado os outros. O programa foi feito para o pic 12f675. Para usar outros PIC’s terá de estudar profundamente os seus datasheets e ver o que está agregado a cada port. Terá que desabilitar funções desnecessárias e habilitar outras. Alguns tem uma seleção de frequência ampla, tendo que inserir código para escolher esta frequência de operação. Talvez a palvra de configuração seja diferente. Enfim, dará um pouco de trabalho. Eu nunca usei este modelo, portanto, não saberia informar em detalhes o que teria que ser feito para mudar o código para ele.
          Cláudio

          1. 0

            Cláudio…gostaria de saber qual é o valor do resistor que devo usar entre os pinos 3 e 4 do HT6p20B para definir o clock de operação deste. Um resistor de 2M2 irá funcionar com seu firmware?

          2. 0

            Olá Ronantussi!
            Sim. Poderá usar 2M2 que é o valor que vem na maioria dos controles comerciais. Existe uma boa margem de tolerância para o funcionamento, apenas não testei ainda o máximo e o mínimo.
            Cláudio

          3. 0

            Cláudio,
            Realmente lhe perguntei isso pois não funcionou o protótipo. Montei conforme o que me mostrou, aperto o botao LEARN, o led LEARN fica aceso, eu aperto o TX do controle e nada. Da o tempo e o led LEARN se apaga mas nada acontece. Descomentei o controle que estou usando e montei o esquema igualzinho no protoboard. Sabes onde posso estar errando? talvez nas saidas que acendem os leds?

          4. 0

            Olá Ronantussi!
            Vocé deverá certificar que a:
            1) frequência do seu transmissor seja a mesma do receptor, pois existe modelos de tx e rx para várias frequências. Para ter certeza que o receptor está recebendo a transmissão, coloque um pequeno disco piezoelétrico em serie com um resistor de 2 a 5 k, do pino OD (out digital) ao gnd. Ao apertar o tx deverá ouvir um som peculiar de transmissão, se estiver recebendo corretamente. Se não ouvir, verifique se o tx está funcionando corretamente (verifique a bateria de 12 volts e conexões) e se ambos (tx e rx) são da mesma frequência.
            2) Certifique de ter compilado um hex com a opção para ht6p20b, senão carregará o pic e não funcionará ( o Hex do site é para pt2262). Portanto, deverá abrir um novo projeto no compilador CCS , anexando o arquivo ‘.c’, já comentando as opções não usadas e descomentando a opção para ‘ht6p20b’. E com este novo hex, deverá usa-lo para gravar o pic.
            3) Confira todas as ligações na montagem, conferindo pino a pino.
            4) Meça a tensão de alimentação e certifique que seja 5 volts.
            5) Se tudo ok, até aqui, tente aproximar o tx do rx e aperte o botão ‘learn’. Acenderá o led de apredizado, em seguida, aperte um dos botões do controle. Deverá apagar imediatamente, se tudo estiver correto, e passará a funcionar com o toque da tecla.

            Espero que seja de ajuda o acima

            Cláudio

          5. 0

            Ola CLáudio.
            A gente fez os testes usando um osciloscopio e comprovou q o circuito esta funcionando. Qual a versão do CCS que você esta utilizando? Pois quando se atualiza o CCS, alguns programas que antes funcionavam param de funcionar.

          6. 0

            Olá Ronantussi!
            Você confirmou com o osciloscópio que está funcionando o tx e rx corretamente (emitindo e recebendo corretamente) . Você está usando o PIC 12f675 ou migrou para outro modelo? A versão é bem antiga -> CCS PCM C Compiler, Version 3.200.
            Cláudio

  26. 0

    Boa tarde Larios, primeiramente queria parabenizá-lo pelo post, um assunto muito interessante e esta me ajudando muito a desenvolver um trabalho na área.
    Tenho uma pequena dúvida, estou utilizando um chip HCS para transmitir, porém adaptei o código que fez para utilizar com um PIC16F876A, cadastra o controle normalmente, porém não estou conseguindo acionar as saídas, estou utilizando os Pinos C0 à C3 do meu PIC. Se puder me dar uma ajudo fico grato.

    Obrigado.

    1. 0

      Olá Renan! Agradeço seu comentário apreciativo. Quando se muda de pic deverá ficar atento que mudará os endereços dos registradores de sentido de porta e poderá existir outros periféricos usando o mesmo pino. Isto complica um pouco. Comece observando atentamente se está carregando o valor correto para o TrisC no começo do ‘main’. Tente colocar uma linha de código para ligar a saída c3 por exemplo e ligue nele um led com resistor de 470 ohms ao gnd. Compile e veja se aciona ou não a saída. Se não acionar, verifique de novo se está resetando o bit de forma correta no trisC. Verifique se não tem periféricos assumindo o pino, estudando cuidadosamente o datasheet, em especial o que está sendo compartilhado nos pinos c0 a c3. A casos que precisamos desligar conversores analógicos,desligar comparadores, etc, pois no reset eles já entram assumindo a porta. Desejo uma boa diversão para você!
      Cláudio

  27. 0

    Olá Larios, é meu primeiro acesso no site. Fiquei muito empolgado com as postagens, já que estou iniciando com programação. Quando tiver alguma dúvida ou até algo interessante para compartilhar o farei.

    Parabéns pelas postagens!

    1. 0

      Olá Joarez! Agradeço seu comentário apreciativo e sua disposição em ajudar. Fique a vontade em compartilhar suas idéias.
      Cláudio

  28. 0

    Boa tarde Cláudio.
    É possível implementar neste programa mais uma função para utilizar os controles de 4 botões com HT6P20D??? pois não encontro os controles com o CI PT2262 e PH2240B. Obrigado.

    1. 0

      Olá Roberto! Vou analisar a viabilidade de sua sugestão e se for bem sucedido, postarei em um artigo futuro.
      Cláudio

      1. 0

        Boa tarde Claúdio.
        Testei o programa para o HT6P20D funcionou o acionamento dos 04 botões, mas em alguns momentos quando precionado qualquer um dos botões as 04 saídas acionando simultaneamente pode ser alguma coisa com a montagem do meu circuito ou com o compilador, estou utilizando um PIC 12F629 e o compilador PIC C Compiler, já encomendei o PIC12F675 mas chegará somente na próxima semana.
        Pergunto, para o transmissor de 03 botões com o HT6P20B não está habilitado??? Testei mas não funcionou com o controle de 03 botões. Obrigado.

        1. 0

          Olá Roberto! O terceiro botão do controle nada mais é do que o acionamento simultâneo dos 2 outro botões. Usando a opção de código para ht6p20b já faz esta função. Já usando a opção para ht6p20d, não foi incluida no código, pois daria confusão. Com o ht6p20b conseguimos obter 3 possibilidades + o desligado. Com o ht6p20d poderemos ter até 15 combinações + o desligado. Vai vendo a confusão que dá! Quanto ao acionamento simultâneo, confesso que não pude testar o circuito por não dispor de um ci ht6p20d.
          Cláudio

  29. 0

    Prezado Larios,

    Eu cometi um tremendo engano, estou envergonhado do meu erro.

    Eu lhe enviei um email, com uma dúvida sobre o chip 6p20B,

    Pois bem, o problema já foi detectado, era um erro de falta de atenção de nossa parte:

    Como o 6p20D utiliza 4 bits para as chaves ou seja d0, d1, d2 e d3 e o outro chip o 6p20b usa apenas as chaves d0 e d1, aquí estava o problema, estava-mos esquecendo de ajustar a leitura correta, ora para 20 bits, ora para 22 bits na recepção, dái o erro.

    Já descobrimos a falha que era nossa, portando os chips estão todos funcionando corretamente,

    ….Mas fica aquí adica para os amigos, não se esqueçam deste detalhe, quando forem receber outro chip da linha 6p20x, com relação aos bits de endereçamento que podem aumentar ou diminuir, depende da quantidade de chaves do chip 6p20x…

    Agradeço a atenção,

    Atenciosamente,
    Marcos

  30. 0

    Boa tarde, Larios, tudo bem.

    Meu amigo, eu estou tendo um problema e gostaria de compartilhar com você, no intuito de saber se você já notou um “DEFEITO” no HT6p20B. É o seguinte:

    No chip 6p20B existem dois pinos 1 e 2 (D0 e D1) destinados ao envio das chaves, de acordo com a seleção feita, certinho: Tipo: 11, 10 e 01.

    Eu tenho notado que em alguns chips HT6p20B (os que tem o carimbo da HOLTEK e os que não tem este carimbo), os que tem o carimbo da HOLTEK, funcionam corretamente ao se fazer a programação acima mencionada e recebemos direitinho no receptor com o pic12F629 que você desenvolveu o código, aliás parabéns…pela iniciativa.

    Mas nos chips 6p20B que não tem o carimbo HOLTEK sobre o chip, os códigos de programação dos pinos 1 e 2 não correspondem, são enviados códigos D0 e D1 que não tem nada a haver com a programação feita no 6p20b

    Será que existe, chips piratas…ou será que existe algum mistério nestes chips ou eu estou ficando maluco ou eu não estou entendendo o funcionamento…

    Eu fiz um relatório detalhado sobre, se possível me mande um email para trocarmos idéias a respeito.

    Atenciosamente,
    Marcos

    1. 0

      Olá Marcos! Eu pessoalmente não notei isto, provavelmente porque uso os mesmos controles repetidas vezes para testar os projetinhos. Mas se alguém puder retornar alguma informação, fica aberto esta questão para comentários.
      Cláudio

  31. 0

    lario voce conhece mesmo,suas ideias tem me ajudado a comprar varias horas,nao sei como te agradecer e nem tenho palavras para expressar o que eu gostaria,mesmo assim meus sinceros parabens e na oportunidade que voce tiver acrescente no seu small book um artigo de pwm em c valeu tambem e de grande elogio o nome (flex) bacana.

    1. 0

      Olá José! Obrigado por seu comentário incentivador. Acrescentarei também o pwm no ‘small boook’ (I think that ‘little book’ is better!).
      Cláudio

  32. 0

    Fico muito feliz amigo que vc tenha dado seus passos para linguagem C e isso nos inspira em não desanimar pois para quem conhece e gosta de outra linguagem se aventurar no desconhecido ,so posso dizer que vc é exemplo de força de vontade , obrigado mais uma vez pelo seus feitos

    1. 0

      Olá Liliano! Obrigado por seu comentário apreciativo. Fico feliz de ter sido de ajuda, de alguma forma. Mas os créditos cabem Aquele que nos permite ter ‘sabedoria’ e ‘conhecimento’, para fazer nossas vidas melhor.
      Cláudio

Comments are closed.