Rádio frequência com Arduino (com strings)

rádio frequência com Arduino
rádio frequência com Arduino
rádio frequência com Arduino

Rádio frequência (ou RF)

Poderia não ser algo tão simples, mas felizmente alguém desenvolveu uma bela biblioteca para interagir com rádio frequência com Arduino. Por esse motivo inicio o post dizendo claramente; esse é um tutorial nível 1, para qualquer iniciante, mas também um atalho para os experientes.

Esse módulo trabalha  à 433MHz e tem um alcance de até 90 metros em espaço aberto. Sua comunicação é um bocado lenta, podendo variar entre 0 e 9200bps; quanto maior a distância, menor deve ser a velocidade para reduzir a taxa de erros. De qualquer modo, esse não é um dispositivo para interfacear com downloads de sistemas operacionais, além de quê, velocidades de 4200bps são suficientes para diversos tipos de tarefa como por exemplo, abrir portões, acionar relés e tarefas simplistas, na qual se inclui controle remoto para robôs etc.



Se você chegou a esse artigo, sorte minha, porque uma breve pesquisa no google retornará para você muitos outros tutoriais sobre o mesmo assunto, mas eu não poderia deixar de escrever a respeito, uma vez que esse módulo receptor-emissor é extremamente barato e prático de utilizar.

Onde comprar o transmissor-receptor RF

Eu compro quase tudo pelo Mercado Livre. Esse produto você encontra fácil, mas recomendo esse vendedor porque ele tem alguns produtos diferentes como chip de rádio FM, gravador/player para Arduino, chip modulador de voz e outros. Considerando o baixíssimo custo desse conjunto emissor-receptor, vale muito a pena comprar mais alguns brinquedos junto pra compensar o frete. Todos estes que citei (e mais alguns) virarão artigo aqui no site, é só acompanhar.

Biblioteca VirtualWire para rádio frequência com Arduino

No documento do autor da biblioteca ele descreve uma variação de distância que pode chegar a 150m à 1000bps em campo aberto, mas dá pra entender que esse ‘campo aberto’ deve ser algo como a superfície lunar, porque corpos humanos, objetos e a posição dos módulos influenciam na qualidade de transmissão, portanto, faça seus próprios testes.

Utilizar um fio rígido de cobre como antena aumenta consideravelmente o sinal e é realmente sugerido. Veja na imagem d receptor que um dos 4 pinos é para a antena, mas ela não é obrigatória.

O pino pode ser selecionado pela funçao ‘vw_set_*_pin() ‘ e o wiring é tão simples quanto se possa imaginar. No próprio documento (caprichadíssimo por sinal) você verá estas representações para wiring:

rádio frequência com Arduino - Receptor (RX)
rádio frequência com Arduino – Receptor (RX)
rádio frequência com Arduino - Transmissor (TX)
rádio frequência com Arduino – Transmissor (TX)

 

Primeiro passo – baixar e disponibilizar a biblioteca





Nesse link você encontra uma biblioteca excelente para interagir com o dispositivo de rádio frequência com Arduino e acredite, não é uma biblioteca trivial, são mais de 400 linhas de código pra entregar uma interface limpa para o programador da aplicação (nós). Após baixar a biblioteca, siga os passos padrão, descomprimindo-a dentro do diretorio ‘libraries’ do Arduino. Supondo a IDE 1.6.7 (já antiga na data desse post, mas ainda a utilizo):

cd
cp Downloads/VirtualWire.rar arduino-1.6.7/libraries
cd arduino-1.6.7/libraries
unrar x VirtualWire.rar && rm -f VirtualWire.rar
#no caso da versao zip:
unzip VirtualWire.zip && rm -f VirtualWire.zip

Se você estiver com a IDE do Arduino aberta, feche-a e abra-a novamente para que seja feita a releitura das bibliotecas.

Segundo passo – fazer o wiring

rádio frequência com Arduino
rádio frequência com Arduino

Siga o desenho disposto mais acima. Você pode escolher o pino que quiser, só sugiro que em ambas as controladoras seja utilizado o mesmo pino para reduzir a probabilidade de engano. Atente também ao esquema acima, porque o transmissor está com o VCC silkado no terceiro pino, mas se você reparar no canto, está escrito ATAD (que foi uma cagada ao fazer o silk, porque na verdade é DATA). Portanto, VCC é o pino do meio e à esquerda, DATA.

No receptor, o pino ao lado do VCC é o pino de dados. O primeiro pino após o pino de dados é a antena, você pode colocar até um clip de papel que terá seu efeito como antena, mas para esse teste tão próximo que estou fazendo (para aproveitar o mesmo notebook) sequer necessita antena.

Terceiro passo – codificar

Esse é o passo mais simples porque não tem segredos. Para mostrar a recepção dos dados transmitidos fiz uma brincadeira com LED RGB, enviando a string formatada para o receptor, com um pequeno parsing só pra brincar.

Vou discorrer sobre o código em comentários nele mesmo.

Transmitter

#include <VirtualWire.h>
#define TX_PIN 7

//guardara o resultado final
String rgb;
//so faz a transmissao se houver mensagem da serial
bool go = false;

void setup(){
    //o comum de sempre; inicia a serial a 9600
    Serial.begin(9600);
    vw_set_ptt_inverted(true);
    vw_set_tx_pin(TX_PIN); //pino para transmitir
    vw_setup(2000);// velocidade ate 9000
}

void loop(){
    if (Serial.available() >0){
      //parsing pra validar
      int red = Serial.parseInt();
      int green = Serial.parseInt();
      int blue = Serial.parseInt();

      if (Serial.read() == '\n') {
          //garante o limite minimo e maximo
          red   = constrain(red, 0, 255);
          green = constrain(green, 0, 255);
          blue  = constrain(blue, 0, 255);
      }
      //Recompoe a string, agora garantindo o formato
      char RED[4],GREEN[4],BLUE[4];
      sprintf(RED,"%03d",red);
      sprintf(GREEN,"%03d",green);
      sprintf(BLUE,"%03d",blue);

      rgb =  String(RED) + "," + String(GREEN) + "," + String(BLUE);
      go = true;
    }

    if (go){
        char result[27];
        rgb.toCharArray(result,rgb.length()+1);
    
        Serial.println(result);
        vw_send((uint8_t *)result, strlen(result));
        vw_wait_tx(); //aguarda 'passar pela garganta'
        go = false;
    }
}

Como você pode notar, o único cuidado que tomei foi de não interromper o fluxo mas também não ficar executando nada à toa. De resto, é um processo muito básico. Em relação ao formato da mensagem, só fiz questão de garantir o formato antes do envio, afinal, é mais fácil garantir o formato antes de sair do que fazer parsing no destino em busca de erros, certo?

Receiver

#include <VirtualWire.h>
#define RX_PIN 7

//pinos PWM do LED RGB
#define R 3
#define G 5
#define B 6

//essa estrutura tem o proposito de economizar. Se tiver duvidas,
//leia:
//http://www.dobitaobyte.com.br/programar-em-cc-para-microcontroladoras-pic-e-arduino/

struct devices
{
    int d        : 3;
    int j        : 3;
    int RGB[3] = {0};
    int     times[3];
};

struct devices valuesRGB;

void setup(){
    //coloca os pinos do RGB em OUTPUT 
    pinMode(R,OUTPUT);
    pinMode(G,OUTPUT);
    pinMode(B,OUTPUT);

    /comeca em branco
    digitalWrite(R,255);
    digitalWrite(G,255);
    digitalWrite(B,255);
    
    //multiplicador
    valuesRGB.times[0] = 100;
    valuesRGB.times[1] = 10;
    valuesRGB.times[2] = 1;
    
    //configuracao e inicializacao do receptor
    vw_set_ptt_inverted(true);
    vw_set_rx_pin(RX_PIN);
    vw_setup(2000);  //velocidade compativel com o emitter
    vw_rx_start();       //inicio da recepcao
    //serial para debug
    Serial.begin(9600);
}

//nao esta em uso, mas sempre crio pra limpar array de char
void clear(char *var){
  for (int k=0;k<strlen(var);k++){
      var[k] = 0;
  }
}

//recebe o array e aplica os valores ao LED
void changeLEDcollor(int* rgb){
    analogWrite(R,rgb[0]);
    analogWrite(G,rgb[1]);
    analogWrite(B,rgb[2]);
}

//conversao para RGB
void toRGB(uint8_t *msg, uint8_t msgLen){
    int i = 0;
    valuesRGB.j = 0;
    valuesRGB.d = 0;
    valuesRGB.RGB[0] = valuesRGB.RGB[1] = valuesRGB.RGB[2] = 0;
    for (int i=0;i<msgLen;i++){
        if (i == 3 || i == 7){
            i++;
            Serial.println(valuesRGB.RGB[0]);
            Serial.println(valuesRGB.RGB[1]);
            Serial.println(valuesRGB.RGB[2]);
            valuesRGB.d=0;
            valuesRGB.j++;
        }

        valuesRGB.RGB[valuesRGB.j] += (msg[i]-48) * valuesRGB.times[valuesRGB.d];
        valuesRGB.d++;
    }
}

void loop(){
    //Le e determina os limites
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;

    if (vw_get_message(buf, &buflen)){
        if (buf[0] == '-'){
            valuesRGB.RGB[0] = 0;
            valuesRGB.RGB[1] = 0;
            valuesRGB.RGB[2] = 0;
            changeLEDcollor(valuesRGB.RGB);
        }
        else{
            toRGB(buf,buflen);
            changeLEDcollor(valuesRGB.RGB);
        }
    }
}

Simples também, hum? Gosto de fazer testes assim, é bem divertido escrever código pra teste.

O video só mostra o LED RGB mudando de cor conforme mando o comando, só pra mostrar esse código funcionando, nem recomendo o video, mas aí está.

Inscreva-se no nosso newsletter, alí em cima à direita e receba novos posts por email.

Siga-nos no Do bit Ao Byte no Facebook.

Prefere twitter? @DobitAoByte.

Inscreva-se no nosso canal Do bit Ao Byte Brasil no YouTube.

Nossos grupos:

Arduino BR – https://www.facebook.com/groups/microcontroladorarduinobr/
Raspberry Pi BR – https://www.facebook.com/groups/raspberrybr/
Orange Pi BR – https://www.facebook.com/groups/OrangePiBR/
Odroid BR – https://www.facebook.com/groups/odroidBR/
Sistemas Embarcados BR – https://www.facebook.com/groups/SistemasEmbarcadosBR/
MIPS BR – https://www.facebook.com/groups/MIPSBR/
Do Bit ao Byte – https://www.facebook.com/groups/dobitaobyte/

Próximo post a caminho!

Agregador de Links - Loucuras da Net

Deixe uma resposta