Arduino seletor automático de antenas para radios icom

[aphawk]

PROJETO DE SELETOR AUTOMÁTICO DE ANTENAS PARA RÁDIOS ICOM USANDO INTEFACE CI-V ( CAT ) E ARDUÍNO UNO PROGRAMADO EM BASCOM

 

Recentemente adquiri um rádio moderno para a minha estação de rádio-amador, o modelo que escolhi foi um Icom IC 7300, de última geração,  com uma excelente relação de custo benefício.

 

Diferentemente dos modelos da Yaesu, que costumam vir com mais de um conector para ligar uma antena externa, esse rádio tem apenas um único conector, o que complica o uso de quem, como eu, possui várias antenas.

 

Isto me obrigou a criar um aparelho que permita a escolha de uma antena, o que normalmente é feito de forma manual, ou seja, caso eu queira utilizar em uma determinada frequência que não seja atendida pela antena selecionada, tenho de me lembrar de mudar manualmente uma chave seletora, e escolher a antena que permite o uso daquela frequência escolhida.

 

Então, resolvi que poderia automatizar essa escolha, pois esses rádios possuem uma interface chamada CAT padrão CI-V, sigla de Computer Aided Transceiver, que foi introduzida no início da década de 2000 para permitir que um computador possa ser conectado ao rádio e assim poder fazer o controle do mesmo. Alguns rádios também possuem essa interface CI-V tanto no formato comum com conector P2 como também no formato USB, prontinha para ser ligada direto a um computador.

 

Vou detalhar a seguir essa interface e algumas variantes, para então explicar o funcionamento nos rádios da Icom.

 

Paulo

 

[aphawk]

A interface simples CI-V utiliza um simples conector P2, portanto usa apenas dois fios : um é o terra ( GND) , e o outro é um sinal que pode ser bidirecional, e no lado do rádio sempre é um circuito do tipo open-coletor.

Desta maneira, do lado de nosso circuito ( ou do computador ) basta apenas um simples resistor de carga, ligado aos +5v, e o outro é ligado ao sinal da interface CI-V.

 

Portanto : para lermos esses sinais, basta apenas ficar monitorando o nível da tensão nesse pino de sinal, que vai de 0 Volts a +5V , e se quisermos também enviar algum sinal, bastaria apenas um simples transistor com o coletor ligado a esse sinal, e o emissor ligado ao terra ( GND). Quando quisermos enviar um nível 0, basta alimentar a base do transistor; se quisermos um nível 1 basta não deixar o transistor conduzir.

 

No nosso caso, que vamos apenas ficar "escutando" a conversa entre o computador e o rádio, não vamos precisar nem mesmo desse simples transistor, usaremos apenas o resistor de carga, e vamos ligar esse pino diretamente à entrada de nosso microcontrolador.

 

Os sinais do protocolo são sempre enviados no formato serial, sendo que a velocidade pode variar entre 1200 e 19200 Bauds, com o padrão sendo 4800, e o formato dos dados sempre é o famoso 8N1, isto é , 8 bits em sequência, sem o bit de paridade, e apenas 1 stop bit.

 

Já no caso de se utilizar a saida USB do rádio para fazermos o controle CAT, a velocidade pode ser bem maior, sendo comum encontrarmos 38400 Bauds, mas aí existe um senão : quando usamos o controle via USB, os sinais também são ecoados na saída CI-V, a qual não suporta altas velocidades, então eu recomendo sempre utilizar a velocidade padrão de 4800 Bps, mesmo na interface USB.

 

A seguir, vou apresentar o protocolo de uma maneira bem simplificada, isto é, explicarei apenas os comandos que me interessam, pois o protocolo hoje está bem sofisticado, tendo mais de 100 comandos e sub-comandos diferentes para acompanhar a evolução dos recursos dos rádios modernos.

 

Paulo

 

[.if]

Paulão apesar de não ser meu ramo, obviamente considero interessante sua iniciativa e seu projeto. Se me permitir, permita-me permitir-me uma mensagem sublininar: 1.jpg>1K.txt

abç

[aphawk]

@Isadora Ferraz ,

 

Com certeza ! 

Já vou colocar algumas imagens sobre o protocolo e circuitos utilizados.

 

 

adicionado 23 minutos depois

A concepção da Icom em fazer essa interface está apresentada abaixo :

 

 

Reparem que é possível controlar vários rádios, de um mesmo computador.  O elemento "centralizador" da conversa era vendido pela Icom como CT-17, e custava cerca de US$ 200 ....

 

Claro que não é o meu caso, pois eu uso apenas um rádio ligado ao computador.

 

Já olhando do lado dos computadores, a maneira de se conectar era usando uma das interfaces seriais ( as famosas COM1 e COM2, lembram disso ???? Eram encontradas em todos os computadores, no formato DB-25 e mais tarde no DB9 ) padrão RS232C. Então era necessário algum circuito para compatibilizar os sinais que viriam do conector P2 do rádio para os níveis de tensão positivos e negativos que a interface padrão RS-232 utilizava.

 

Usava-se algo deste tipo :

 

 

Ou seja, um simples conversor baseado no MAX232 velho de guerra....

 

Mas já faz um bom tempo os computadores não utilizam mais interfaces seriais RS232, e sim interfaces USB, então foi preciso atualizar a interface usando aqueles famosos CI's que convertem de USB para Serial, como o FT232 e outros parecidos, facilmente encontrados hoje em módulos até no Mercado Livre.

Segue um exemplo :

 

 

Apresentei tudo isto acima apenas para mostrar o que é necessário para se ligar um computador ao rádio... mas para o nosso seletor de antenas não vamos precisar de nada disso, vamos apenas ler os sinais do conector P2 da interface CI-V.

 

Os rádios mais modernos já apresentam uma interface serial ou USB , além da interface P2, para fazer a ligação ao computador. Desta maneira temos o conector P2 livre para ligarmos ao nosso circuito.

 

Paulo

[aphawk]

Vamos examinar o protocolo da Icom :

 

 

Todas as mensagens começam com dois bytes $FE em sequência, e terminam com um byte $FD.

 

A seguir, um endereço hexadecimal, que define para quem  a mensagem está sendo enviada, e um outro endereço hexadecimal que define quem está enviando a mensagem . Na figura acima são os terceiro e quarto bytes, marcados como To e Fm.

 

O quinto byte é o chamado COMANDO, que define o comando que deve ser feito por quem está recebendo a mensagem.

 

A seguir, pode vir um outro byte de SUBCOMANDO, pois alguns comandos possuem muitos subcomandos.... ou podem vir uma sequência de 4 ou de 5 bytes especificando a frequência de operação do rádio.

 

Aqui começa a encrenca... os rádios mais antigos usavam apenas 4 bytes , e os novos usam 5. Temos de ficar controlando o comprimento da mensagem para sabermos com certeza qual é o caso.

 

Os comandos usados para transmitir a frequência ( entre outras coisas ) são 3 :  00H, 03H, e 05H.

 

Basta monitorarmos para sabermos se é a mensagem que precisamos decodificar.

 

Vamos ver o formato desses bytes que contém a frequência :

 

 

Esses bytes estão codificados no formato BCD, isto é, cada nibble de 4 bits representa um dígito decimal !

No caso de rádios que usam 5 bytes, temos 10 dígitos no total, indo desde 1 Hertz até 9.999.999.999 Hertz !

Já no caso de se ter 4 bytes, temos 8 dígitos apenas, e não é possível setar nem a unidade e nem a dezena, podemos usar apenas de 100 Hz até 9.999.999.900 Hertz.

 

Basta apenas pegar o byte, e dividir em dois nibbles, e pronto, temos os dois dígitos decimais, os quais devem ser multiplicados pelos respectivos pesos de sua posição. Para o exemplo acima, depois do comando 05H temos a sequência :

76H  =  7 X 10 + 6 X 1 = 76

23H = 2 X 1.000 + 3 * 100 = 2.300

28H = 2 X 100.000 + 8 * 10.000 = 280.000

45H = 4 X 10.000.000 + 5 X 1.000.0000 = 45.000.000

01H = 0 X 1.000.000.000 + 1 X 100.000.000 = 100.000.000

Somando tudo, temos 145.282.376 Hertz.

 

Agora, já sabemos de tudo o que precisamos : vamos monitorar as mensagens, e quando recebermos uma delas ( saberemos pelo byte terminador que é o $FD ), vamos ver se é válida procurando pelos dois bytes $FE em sequência, depois o byte de comando, e se for um dos três bytes que procuramos, vamos ver o comprimento da mensagem para sabermos se a frequência está sendo transmitida com 4 ou com 5 bytes.

 

No caso do meu rádio, que é o IC7300, o comprimento é sempre de 5 bytes, mas implementei a checagem para poder ser utilizado em outros rádios mais antigos.

 

Vamos partir para o hardware.

 

Paulo

[aphawk]

 

Esse é o circuito básico, onde estão mostrados apenas dois conjuntos acionadores dos relés de antenas para não tornar o desenho muito cheio....

 

Do lado direito, temos os conectores J2 e J3, que são duas entradas de antenas das bandas 1 e 2 respectivamente, e o conector J4 é o conector de saída de antenas, que irá direto ao rádio.

O conector J5 é para a ligação de uma fonte de alimentação de 12Vdc por pelo menos 0,5 A , do tipo de parede, pequena.

A entrada CAT é o conector J1 do lado esquerdo do circuito.

 

Nesse circuito são necessários duas fontes de alimentação uma para o Arduíno, com tensões padrão entre 9 e 12 V, e outra para os relés, de 12V.

O resistor R1 tem de ser ligado ao +5V disponível nos terminais do Arduino.

 

Observem outra coisa : os pinos de negativo das fontes não devem ser ligados juntos sob hipótese nenhuma !

Isso é muito importante para tentar evitar que algum raio que caia nas proximidades atinja o circuito.

 

Utilizei um optoacoplador para isolar totalmente os circuitos, por causa da quantidade enorme de RF que existe ; reparem que utilizei um circuito para abaixar a sensibilidade dos optoacopladores mediante o pino de base do transistor existente dentro deles, algo não muito comum, além de utilizar um capacitor em paralelo com o Led existente no opto-acoplador, para eliminar qualquer interferência devido à RF

 

Os relés utilizados são de bobina de 12Vdc , com dois pólos reversíveis, e configurados de maneira que quando o relé estiver em repouso ele liga a entrada de antena diretamente ao terra dela, fazendo um curto-circuito e assim eliminando qualquer sinal proveniente dela.

 

Quando o Arduíno acionar um dos circuitos, o Led correspondente vai acender também, o opto vai conduzir, o relé vai acionar, e a antena selecionada vai estar disponível no terminal de saída.

 

Paulo

 

[.if]

Paulão... Aí sim hein.. com desenho é mais fácil de dar pitacos (mesmo eu não entendendo paul newman desta área kk)

São relés comuns? Mesmo sendo circuito RF e de potência? Quando liga um, a transmissão do outro é cortada né? Afinal os sinais estão bem perto: nos contatos . Pois vai que um zoa o outro. Ah táh.. são só "entradas". Obviamente já pensas na otimização do layout, claro.

 

Tudo bem.. você isolou os controles dos relés e provavelmente vai isolar os controles da comunicação com o rádio né? acoplador, wireless, "brutufi" ou algo do gênero

 

ok.. não somei nada. Só conjecturas mesmo.

[aphawk]

@Isadora Ferraz ,

 

Na verdade eu usei relés da Schrack, com contatos banhados a prata mesmo, paguei R$ 16,00 em cada no Mercado Livre. Mas já ví montarem com esses relés chineses de R$ 1,00 cada , e para 100W eles funcionam sem problema. É que eu pretendo usar um amplificador linear, então no meu caso terão de suportar 1000 Watts !!!!!

 

Quando selecionar um deles, apenas esse será percorrido pela corrente de RF na hora da transmissão, ou na recepção. Todos os outros estarão aterrados dando curto-circuito nas antenas, o que evita possíveis interferências, e desconectados da saída

 

O truque na montagem é usar uma blindagem dentro da caixa metálica, tipo o circuito com o Arduíno e os Leds de saída ficam logo na parte da frente da caixa, aí no meio dela coloca uma blindagem metálica , como se fosse o fundo da caixa, e fazemos um furo pequeno nela apenas para levar os fios de acionamento dos opto para o outro lado, onde ficam os circuitos do opto e relé.

 

Nessa parte de trás, ficam todos os circuitos que a RF pode afetar, os conectores das antenas são fixados direto na caixa metálica, e fazemos uma pequena placa PCB, pode ser dessas prontas perfuradas, soldamos os opto e os componentes em volta deles, e colocamos os relés bem perto dos conectores, fazendo a conexão entre eles com fio de cobre sólido mesmo, tipo 16 AWG tá ótimo.

 

Muito importante é não aterrar nada que pertença ao circuito do Arduino na caixa metálica ou no circuito dos opto/reles, senão perdemos toda a isolação galvânica , pois os conectores das antenas já fazem o aterramento.

 

Entre todos os relés, passamos mais um fio de cobre sólido entre eles, interligado justamente os pinos dos relés que irão soldados até conector de saída.

 

Assim, a RF fica apenas nessa parte, e os truques usados nos optoacopladores resolvem os problemas da RF.

 

É uma montagem que os radio-amadores sabem como fazer, pois tiveram de prestar exame, certo ? kkk

 

No meu protótipo eu não fiz nada disso, deixei o Arduíno do lado de fora da caixa mesmo só pra ver tudo funcionar kkkk mas oriento a quem quiser montar para tomar essas precauções todas que citei acima.

 

A parte da interface CAT fica ligada no rádio, e acaba tendo contato com ele via terra ( GND) com o Arduíno... poderia fazer o isolamento dela também com um optoacoplador muito sensível, tipo um 4N35, pois a corrente máxima que pode circular na interface é de 0,5 mA . Mas para isso funcionar, teria de puxar um fio de um outro conector do rádio, tal de ACC, que custa uma nota , apenas para puxar uma tensão de +8V que iria fornecer a corrente pelo opto. E esse conector não se acha aqui no Brasil ... e teria de fazer alguns testes com o circuito eliminador de RF que fica na base do transistor, pois ele é Darlington e terei de alterar o resistor ( e talvez o capacitor também... ).

 

Pensei em utilizar mais uma fonte dessas comuns de parede, e alimentar essa interface por ela, assim a única coisa que teria conectada no rádio seria essa fonte adicional de parede... mas dá muito trabalho isso kkkk   eu prefiro desconectar o cabo CAT quando não estiver usando.

 

Também poderia fazer a isolação completa usando dois módulos baseados nos SI qqr coisa da vida, que fazem link serial sem fio, mas teria de fazer uma caixa separada para o transmissor, com uma fonte adicional...  são ideias , idéias .....

 

Paulo

[.if]

3 horas atrás, aphawk disse:

A parte da interface CAT fica ligada no rádio, e acaba tendo contato com ele via terra ( GND) com o Arduíno

Ah.. neste caso suponho que a saída de antena que vai pros relés é isolada, sem contato com gnd lógico né? Tipo um secundário dum trafo.

Se o terra do seu rádio é o mesmo terra da antena e vai pro terra do arduíno , penso que a isolação via opto cai por terra, não?

 

Ah , a propósito

3 horas atrás, aphawk disse:

pequena placa PCB, pode ser dessas prontas perfuradas,

... ja falei que tenho muitas placas destas e tenho interesse em dispor a valor simbólico? Já? E que dia foi? hoje?? aff memória fraca

 

[aphawk]

@Isadora Ferraz ,

 

kkkk sim eu ví você dizer isso sobre as placas perfuradas no Fórum de Eletrônica kkkkk

 

Sobre a saída de antenas ... infelizmente não é isolada, ela está no chassis do rádio, na parte traseira , e é o mesmo terra que liga o conector de saída Cat. Mas esse local também tem um parafuso para fixação de um terminal de aterramento, que é obrigatório fazer para eliminar problemas de raios.

 

Muita vezes o que atinge a antena não é o raio principal, e sim uma pequena faísca , mas ela atinge a antena e vai sendo conduzida pelo cabo de antena, e uma vez que chegue dentro do chaveador de antena ele pode percorrer e pular para outros circuitos, é melhor fazer a isolação pelo opto para evitar a queima do Arduíno.

 

Outra coisa, o computador também está conectado pela saída serial ou USB, que também usam o mesmo terra do rádio !

 

Como pode perceber, a finalidade não é proteger dos raios, pois contra um impacto direto não tem o que fazer, vai levar tudo, inclusive o computador. E pode aterrar tudo, torre, antena, não adianta porque ele percorre o cabo interno, e pula pelos circuitos internos, torrando tudo do mesmo jeito.

 

A ideia é isolar da RF que vem do transmissor via cabo, que entra dentro do chaveador de antenas com uma grande intensidade, pois ela pode fazer o Arduíno travar ou ficar meio maluco.

 

Como exemplo, todo dia que eu saio de casa eu desligo o cabo de antena do rádio, desligo o cabo USB do microcomputador, desligo as fontes de alimentação, e desligo também esse cabo CAT com P2 .....  melhor prevenir do que remediar depois ....

 

Paulo

[aphawk]

Vamos ao Software, como sempre escrito em Bascom, e utilizando uma função muito útil : um buffer serial por interrupção, que ajuda uma barbaridade para receber frames.

 

Como vimos acima, o protocolo sempre inicia com dois bytes FE FE, e terminam com um byte FD.

Portanto, se ficarmos armazenando os dados em um buffer, e esperarmos até receber um byte FD, podemos pesquisar esse buffer para verificarmos se temos um frame com os dados que precisamos decodificar.

 

Usamos uma função do Bascom, e um pouquinho de Assembly para podermos copiar os dados desse buffer de recepção para uma matriz e assim podermos fazer o tratamento desses dados calmamente, no programa principal, sem o risco de perdermos alguma coisa devido a alguma rotina de interrupção que demore mais do que o necessário.

 

Quando conseguimos decodificar um frame válido, com um dos 3 comandos que desejamos, vamos fazer a conversão dos dados para a frequência real, e assim basta compararmos com a nossa tabela que informa quais antenas que temos, em que faixas elas trabalham, e quais das saídas de banda que correspondem para cada antena.

 

O software apresentado é apenas a primeira versão, e muitas melhorias podem ser implementadas, como por exemplo tocar um buzzer quando é selecionada uma frequência para a qual não temos antena, informando assim um erro que pode danificar o rádio em caso de transmissão.

 

O programa apresentado não vai acionar nenhuma saída quando for escolhida uma frequência para a qual não exista uma antena , então tomem sempre cuidado com essa possibilidade.

 

Segue o programa :

 

Spoiler

'*******************************************************************************
' COMUTADOR AUTOMATICO DE ANTENAS PARA RADIOS ICOM USANDO INTERFACE CAT
' By Antonio Paulo Hawk PY2APK  (c)2018
' Não pode ser usado para fins comerciais.
'*******************************************************************************

$regfile = "M328pdef.dat"
$crystal = 16000000
$hwstack = 60
$swstack = 90
$framesize = 128
Config Submode = New

' ---------------------------------
' configuração dos pinos de I/O
' ---------------------------------

Config Portc.5 = Output
Banda1 Alias Portc.5
Banda1 = 0
Config Portc.4 = Output
Banda2 Alias Portc.4
Banda2 = 0
Config Portc.3 = Output
Banda3 Alias Portc.3
Banda3 = 0
Config Portc.2 = Output
Banda4 Alias Portc.2
Banda4 = 0
Config Portc.1 = Output
Banda5 Alias Portc.1
Banda5 = 0
Config Portc.0 = Output
Banda6 Alias Portc.0
Banda6 = 0
Config Portb.0 = Output
Banda7 Alias Portb.0
Banda7 = 0
Config Portb.1 = Output
Banda8 Alias Portb.1
Banda8 = 0
Config Portb.2 = Output
Banda9 Alias Portb.2
Banda9 = 0
Config Portb.5 = Output
Flag_f Alias Portb.5
Flag_f = 0

' ---------------------------------
' Dimensionamento das variaveis
' ---------------------------------


Dim B_serial_buffer(30) As Byte
Dim B_final_buffer As Byte
Dim F_tem_dado_serial As Bit
Dim F_tem_freq As Bit
Dim Mymatch As Byte
Dim A As Byte
Dim Temp1 As Byte
Dim Temp2 As Byte
Dim Temp3 As Byte
Dim Mycom1 As Byte
Dim Mycom2 As Byte
Dim Mycontroller As Byte
Dim Mycommand1 As Byte
Dim Mycommand2 As Byte
Dim Mycommand3 As Byte
Dim Temp11 As Long
Dim Temp12 As Long
Dim Freq As Long
Dim Size As Byte
Dim X As Byte
Dim F_ok As Bit
Dim Tab_num(25) As Byte


' -------------------------------------------
' configuração da interface serial e buffer
' -------------------------------------------


Config Com1 = 9600 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
Config Serialin = Buffered , Size = 50 , Bytematch = All

'The following internal variables will be generated :
'_Rs_head_ptr0   BYTE , a pointer to the location of the start of the buffer
'_Rs_tail_ptr0   BYTE , a pointer to the location of tail of the buffer
'_RS232INBUF0 BYTE ARRAY , the actual buffer with the size of SIZE
'_RS_BUFCOUNTR0, a byte that holds the number of bytes that are in the buffer.



Mymatch = $fd
Mycom1 = $fe
Mycom2 = $fe
Mycontroller = $94                                                              ' não usado
Mycommand1 = $05
Mycommand2 = $00
Mycommand3 = $03


' a tabela abaixo indica onde tem uma antena, e qual a saida correspondente dela.
' as bandas são na sequência abaixo :
' 1.8 , 3.5 , 7 , 10, 14, 18, 21, 24, 27, 28 e 50, mas lembro que existem espaços
' entre elas, onde o rádio não pode transmitir, mas pode receber !
' Por exemplo, podemos usar uma antena vertical para receber todas as frequências
' onde não iremos transmitir, e definir uma saída para essa antena.
' Devido a esse fato, a tabela começa compreendendo a ferequência entre 0 e 1.799.999 Hz
' que é o elemento numero 1, e a primeira banda oficial do rádio onde ele pode transmitir
' compreende de 1.8 Mhz a 2 Mhz.
' no meu caso tenho antenas para 40m,30m,20m,17m,15m,12m,11m,10m,6m
' compreendendo apenas 3 antenas físicas , sendo duas dipolos para 40M e 30M e
' uma log periódica que funciona muito bem de 20M até 10M e também funciona
' precáriamente para 6M.
' a tabela no meu caso tem de ser 0;0;0;0;0;0;0;3;0;2;0;1;0;1;0;1;0;1;0;1;1;0;1


Tab_num(1) = 0
Tab_num(2) = 0
Tab_num(3) = 0
Tab_num(4) = 0
Tab_num(5) = 0
Tab_num(6) = 0
Tab_num(7) = 0
' aqui tem a minha antena para 40M na saída 3 do controlador
Tab_num(8) = 3
Tab_num(9) = 0
' aqui tem a minha antena para 30M na saída 2 do controlador
Tab_num(10) = 2
Tab_num(11) = 0
' aqui tem a minha antena para toda a faixa de 20M ate 6M na saída 1 do controlador
Tab_num(12) = 1
Tab_num(13) = 0
' aqui tem a minha antena para toda a faixa de 20M ate 6M na saída 1 do controlador
Tab_num(14) = 1
Tab_num(15) = 0
' aqui tem a minha antena para toda a faixa de 20M ate 6M na saída 1 do controlador
Tab_num(16) = 1
Tab_num(17) = 0
' aqui tem a minha antena para toda a faixa de 20M ate 6M na saída 1 do controlador
Tab_num(18) = 1
Tab_num(19) = 0
' aqui tem a minha antena para toda a faixa de 20M ate 6M na saída 1 do controlador
Tab_num(20) = 1
' aqui tem a minha antena para toda a faixa de 20M ate 6M na saída 1 do controlador
Tab_num(21) = 1
Tab_num(22) = 0
' aqui tem a minha antena para toda a faixa de 20M ate 6M na saída 1 do controlador
Tab_num(23) = 1

F_tem_freq = 0
Enable Serial
Enable Interrupts

De_novo:
   If F_tem_dado_serial = 1 Then
      F_tem_dado_serial = 0
      F_ok = 0
      A = B_serial_buffer(1)
      If A = Mycom1 Then
         A = B_serial_buffer(2)
         If A = Mycom2 Then
            A = B_serial_buffer(5)
            If A = Mycommand1 Then
               F_ok = 1
            Elseif A = Mycommand2 Then
               F_ok = 1
            Elseif A = Mycommand3 Then
               F_ok = 1
            Else
               F_ok = 0
            End If
            If F_ok = 1 Then
               If B_final_buffer = 10 Then
                  Size = 4
               Else
                  Size = 5
               End If
               Freq = 0
               A = B_serial_buffer(6)
               Temp1 = Makedec(a)
               Freq = Temp1
               A = B_serial_buffer(7)
               Temp1 = Makedec(a)
               Temp11 = Temp1 * 100
               Freq = Freq + Temp11
               A = B_serial_buffer(8)
               Temp1 = Makedec(a)
               Temp11 = Temp1 * 10000
               Freq = Freq + Temp11
               A = B_serial_buffer(9)
               Temp1 = Makedec(a)
               Temp11 = Temp1 * 1000000
               Freq = Freq + Temp11
               If Size = 5 Then
                  A = B_serial_buffer(10)
                  Temp1 = Makedec(a)
                  Temp11 = Temp1 * 100000000
                  Freq = Freq + Temp11
               Else
                  Freq = Freq * 100
               End If
               Set F_tem_freq
            End If
         End If
      End If
   End If
   If F_tem_freq = 1 Then
   Toggle Flag_f
      Gosub Mostra_banda
      Reset F_tem_freq
   End If

   Goto De_novo


Mostra_banda:
   For X = 0 To 22
      Temp11 = Lookup(x , Banda_fim)
      If Temp11 >= Freq Then
         Temp12 = Lookup(x , Banda_inic)
         If Temp12 <= Freq Then
         'tudo certinho, dentro da banda
            Goto Sai_banda
         Else
         ' frequencia fora das bandas
         End If
      End If
   Next

Sai_banda:
   Incr X
   Temp2 = Tab_num(x)
   If Temp2 = 0 Then
' NAO TEM ANTENA NESSA BANDA !
' vamos sair sem fazer nada ....
      Goto Sai_banda1:
   End If
' se chegou aqui, tem antena, vamos acionar a saída !
   Gosub Reseta_antena
   Gosub Seta_antena
Sai_banda1:
Return


Seta_antena:
   Select Case Temp2
      Case 1 : Banda1 = 1
      Case 2 : Banda2 = 1
      Case 3 : Banda3 = 1
      Case 4 : Banda4 = 1
      Case 5 : Banda5 = 1
      Case 6 : Banda6 = 1
      Case 7 : Banda7 = 1
      Case 8 : Banda8 = 1
      Case 9 : Banda9 = 1
      Case Else : Nop
   End Select
Return


Reseta_antena:
   Banda1 = 0
   Banda2 = 0
   Banda3 = 0
   Banda4 = 0
   Banda5 = 0
   Banda6 = 0
   Banda7 = 0
   Banda8 = 0
   Banda9 = 0
Return

' ------------------------------------------
' ROTINA DE RECEPCAO SERIAL POR INTERRUPCAO
' ------------------------------------------

Serial0bytereceived:

   $asm
      !PUSH R6
      !push R10
      !PUSH R11
      !PUSH R22
      !PUSH R24
      !PUSH R25
      !PUSH R26
      !PUSH R27
      !PUSH R30
      !in R24, sreg
      !PUSH  R24
      !lds r22,{MyMatch}                                              'load variable MyMatch to Register R22
      !cp r25,r22                                                     'Compare received Byte with MyMatch
      !breq Serial0ByteReceived_Matched                               'If equal, jump to "Serial1ByteReceived_Matched"
      !jmp sai_serial                                                 'Fast back to buffered serial in
   $end Asm

Serial0bytereceived_matched:

   Temp1 = _rs_bufcountr0
   Temp2 = _rs_tail_ptr0 - Temp1
   Incr Temp2
   B_final_buffer = Temp1


   For X = 2 To Temp1
      Temp3 = _rs232inbuf0(temp2)
      Incr Temp2
      Decr X
      B_serial_buffer(x) = Temp3
      Incr X
   Next

   Clear Serialin
   Set F_tem_dado_serial

Sai_serial:

   $asm
      !POP  R24
      !out sreg, r24
      !POP R30
      !POP R27
      !POP R26
      !POP R25
      !POP R24
      !POP R22
      !POP R11
      !POP R10
      !POP R6
   $end Asm
Return

End

' tabela de frequencias correspondendo as bandas normais e nao permitidas

Banda_inic:
   Data 0000001& , 1800000& , 2000000& , 3500000& , 4000000& , 5255000& , 5405001& , 7000000& ,
   Data 7300001& , 10100000& , 10150001& , 14000000& , 14350001& , 18068000& , 18168001& , 21000000&,
   Data 21450001& , 24890000& , 25000000& , 26965000& , 28000000& , 29700001& , 50000000&

Banda_fim:
   Data 1799999& , 1999999& , 3499999& , 3999999& , 5254999& , 5405000& , 6999999& , 7300000& ,
   Data 10099999& , 10150000& , 13999999& , 14350000& , 18067999& , 18168000& , 20999999& , 21450000&,
   Data 24889999& , 24990000& , 26964999& , 27999999& , 29700000& , 49999999& , 54000000&

 

 

O programa, quando compilado, ocupa apenas 2.308 bytes, cerca de 7% da capacidade de um Arduíno Uno, então quem quiser melhorar pode implementar um montão de coisas !

 

Paulo

[aphawk]

Explicações adicionais sobre o programa em Bascom

 

Vou explicar sobre uma função bem poderosa, o SERIALIN.

 

Este comando abaixo :

 

Config Serialin = Buffered , Size = 50 , Bytematch = All

 

Nesse comando foi criado um buffer para a primeira porta de comunicação serial, com interrupção pelo hardware, de tamanho máximo de 50 bytes, e a cada byte recebido é chamada uma rotina de interrupção pré-definida, no caso da primeira serial o label dessa rotina é Serial0bytereceived:

 

Nesse label, eu fiz um trecho em Assembly, para ter alta velocidade, e pesquiso se o byte recebido é o byte que me interessa, no caso com o valor FD em hexa, o qual eu armazenei previamente em uma variável chamada MyMatch .

 

Desta maneira, fica fácil mudar a todo instante qual o valor que me interessa, embora neste programa eu não faça essa mudança, apenas aproveitei um trecho de código já depurado no passado.

 

Assim, caso o byte recebido não seja o que me interessa ( o FD ) , eu simplesmente saio da rotina.

 

Mas se o byte é o que eu aguardo, então eu transfiro o conteúdo do buffer para uma matriz, onde posso pesquisar tranquilamente dentro do programa principal, sem atrapalhar a rotina de interrupção, zero o buffer , e saio da interrupção. 

 

Para facilitar esse trabalho, uso algumas variáveis que são criadas automaticamente pelo comando Serialin, elas estão no programa nos comentários logo abaixo do comando.

 

No programa principal, eu procuro as informações que me interessam, converto elas para frequência, e com esse dado eu pesquiso uma tabela de frequências do rádio, e a partir da posição encontrada nessa tabela, pesquiso uma outra tabela ( a que eu defino quais bandas possuem antenas e qual o número dela ) , e assim posso acionar a saída correspondente.

 

A enorme facilidade de interação entre o Bascom e o Assembly facilita e muito qualquer tarefa onde tempos envolvidos podem ser críticos, como no caso de comunicação serial. Aqui eu uso a velocidade de 9600 Bps, mas nada impede de se utilizar velocidades de 19200 ou 38400 Bps, pois os tempos envolvidos dentro da interrupção, incluindo o tempo para copiar todos os bytes do buffer para a matriz,  são menores do que o tempo envolvido para o hardware receber um único byte a 38400.

 

Paulo