Os computadores pessoais geralmente são conectados entre si por meio de cabos de rede em uma rede de escritório baseada em LAN. Conectar dois computadores usando cabo USB ou cabo RS – 232 para comunicação de dados é uma opção viável quando os dois sistemas são colocados próximos. Além disso, um único cabo de rede conecta um PC a apenas outro PC. Se os sistemas de computador em um escritório forem projetados para comunicar dados sem fio, o custo de instalação de cabos de rede elaborados poderá ser economizado e toda a configuração parecerá mais organizada e limpa. Desta forma, qualquer computador pode ser conectado a qualquer outro computador sem complicações. Um único computador também pode ser facilmente conectado a qualquer número de outros computadores ao mesmo tempo.
Este projeto ilustrou a comunicação de dados sem fio entre PCs usando o módulo RF de 434 MHz. O módulo RF tem um alcance de 50-60 metros e pode ser estendido para 300-350 metros usando uma antena e aumentando a potência de transmissão do módulo. Portanto, a rede de comunicação de dados sem fio baseada em RF pode ser instalada em qualquer pequeno escritório ou local de trabalho. No projeto, como os PCs não podem fazer interface direta com o módulo RF, eles são interligados por meio de placas Arduino. O PC que deve funcionar como servidor de dados é conectado a um transmissor de RF através da placa Arduino, enquanto os PCs que devem funcionar como clientes de dados na rede local sem fio são conectados a receptores de RF através do Arduino. A comunicação de dados foi ilustrada usando o monitor serial em ambos os PCs.
Componentes necessários
| Sr. Não. | Componentes necessários | Quantidade |
|---|---|---|
| 1 | Módulo RF Rx (434Mhz) | 1 |
| 2 | Módulo RF Tx (434Mhz) | 1 |
| 3 | Arduino pro mini | 2 |
| 4 | Computador desktop/laptop | 2 |
| 5 | Bateria – 9V | 2 |
| 6 | Tábua de ensaio | 2 |
| 7 | Conectando fios |
Fig. 1: Diagrama de Blocossou de PC baseado em Arduino para comunicação de dados RF de PC Conexões de Circuito
No projeto, um PC é configurado como servidor de dados e outro PC é configurado como cliente de dados. Muitos PCs podem ser transformados em clientes de dados, mas apenas um PC foi transformado em cliente no projeto para fins de demonstração. O servidor feito para PC é conectado a uma placa Arduino usando o cabo USB e um transmissor RF faz interface com a placa Arduino para transmissão de RF. Para fazer a interface do transmissor RF com o Arduino, seu pino de entrada serial (pino 2) é conectado ao pino 12 da placa Arduino e uma antena é anexada ao pino 4 do módulo transmissor RF para extensão de alcance.
No PC cliente, o PC é novamente conectado ao Arduino usando o cabo USB e a placa Arduino é posteriormente conectada a um receptor RF para uma operação semelhante à do cliente. Para fazer a interface do receptor RF com o Arduino, o pino de saída serial (pino 2) do módulo receptor é conectado ao pino 11 da placa Arduino do lado do cliente e uma antena é conectada ao pino 8 do receptor RF para extensão de alcance. O VCC e o aterramento são fornecidos nos respectivos pinos dos módulos Arduino e RF conforme indicado em suas folhas de dados.
Fig. 2: Protótipo de comunicação de dados RF de PC para PC baseado em Arduino
Como funciona o circuito?
No projeto, os dados são transferidos do PC Servidor para o PC Cliente. O PC servidor transfere os dados a serem transmitidos para a placa Arduino interligada através do cabo USB. O programa monitor serial é usado para transferir dados do PC para a placa Arduino. O Arduino possui o código do programa para ler o caracter transferido para seu buffer e transmiti-lo serialmente para o módulo RF usando as funções da Biblioteca VirtualWire. Como o módulo RF transmite apenas um caractere por vez, o buffer de caracteres recebido do PC deve ser armazenado em uma matriz no código do programa Arduino do lado do servidor.
No PC do lado cliente, o buffer de caracteres transmitido por RF é detectado pelo receptor RF e passado serialmente para a placa Arduino do lado cliente. O código do programa na placa Arduino do lado do cliente lê o buffer de caracteres e o armazena em um array. Os elementos da matriz são posteriormente transferidos em série por meio de um cabo USB para o PC cliente. No PC Cliente, a matriz de caracteres recebida é exibida usando o programa Serial Monitor. Um programa baseado em java também pode ser desenvolvido para transmitir e receber dados das portas USB.
Fig. 3: Imagem mostrando placas Arduino usadas para transferência de dados RF de PC para PC
Guia de programação
No Arduino do lado do servidor, primeiro, a biblioteca VirtualWire é importada para facilitar a interface com o módulo RF.
#include
Um LED está conectado no pino 13 para indicar a transmissão serial em andamento. Assim, uma variável “ledpin” é declarada e atribuída ao pino 13 do Arduino. A variável “MsgData” é declarada para armazenar a leitura de caracteres e o array “MsgcharAR” é declarado para armazenar vários caracteres antes da transmissão serial. Algumas variáveis globais – “length” para armazenar o comprimento da mensagem, “data_available” para verificar a disponibilidade dos dados e um contador “i” são inicializadas.
Uma função setup é chamada, onde ledpin é definido para o modo de saída usando a função pinMode , a taxa de transmissão do sistema é definida para 9600 bits por segundo usando a função Serial.begin e a função vw_setup é usado para definir a taxa de transmissão da transmissão serial RF para 2.000 bits por segundo.
Uma função loop é chamada, dentro da qual a primeira variável de comprimento é inicializada em 0 e os dados seriais são verificados se disponíveis usando a função Serial.available . Se dados seriais estiverem disponíveis, eles serão lidos usando a função Serial.read e armazenados no array MsgcharAR. O contador de comprimento é incrementado e data_available é definido como 1 para lógica booleana. O bloco de código é repetido em um loop While até que os dados seriais estejam disponíveis.
Se os dados estiverem disponíveis, a variável do sinalizador data_available é deixada com uma configuração booleana de 1, então a mensagem armazenada na matriz MsgcharAR é serialmente enviada para o buffer usando a função Serial.print .
A mensagem armazenada no buffer deve ser enviada serialmente em RF. O led que indica a transmissão em andamento é ligado enviando uma lógica HIGH para o ledpin. A mensagem é enviada serialmente em RF usando a função vw_send , onde os caracteres da mensagem são primeiro convertidos para o formato de caracteres não assinados. vw_wait_tx é usado para esperar até que toda a mensagem seja transmitida. Quando a transmissão termina, o ledpin recebe uma lógica LOW para desligar o LED da transmissão em andamento.
O data_available é definido como 0 e cada elemento da matriz MsgcharAR é definido como 0 como valor padrão.
dados_disponíveis = 0;
Isso encerra o código Arduino do lado do servidor.
No Arduino do lado do cliente, o código do programa primeiro importa as bibliotecas padrão necessárias. A biblioteca VirtualWire é importada para permitir a recepção de dados seriais do módulo RF.
O pino 13 onde o LED indicador de progresso da transmissão está conectado é atribuído à variável ledpin e duas variáveis – “Sensor1Data” para capturar a mensagem em forma inteira e “Sensor1CharMsg” para armazenar a representação de caracteres da mensagem a ser exibida são declaradas.
Uma função setup é chamada onde a taxa de transmissão do Arduino é definida para 9600 bits por segundo usando a função Serial.begin . O ledpin é definido para saída usando a função pinMode .
O módulo transmissor e receptor de RF não possui pino Push To Talk. Eles ficam inativos quando nenhum dado está presente para transmitir ou receber, respectivamente. Portanto, vw_set_ptt_inverted(true) é usado para configurar a polaridade push to talk e solicitar que o receptor continue recebendo dados após buscar o primeiro caractere. A taxa de transmissão para entrada serial é definida para 2.000 bits por segundo usando a função vw_setup . A recepção dos dados é iniciada usando vw_rx_start .
Uma função loop é chamada dentro da qual são declaradas a matriz “buf ” para ler o buffer serial e a variável “buflen” para armazenar o comprimento do buffer.
O buffer de caracteres é armazenado na matriz Sensor1CharMsg usando o loop for com o contador inicializado.
O data_available é definido como 0 e cada elemento da matriz MsgcharAR é definido como 0 como valor padrão.
Código-fonte do projeto
###
#include// LED's const int ledPin = 13; int MsgData; //int Sensor2Data; char MsgcharAR(40); int length,data_available; int i; void setup { // PinModes // LED pinMode(ledPin,OUTPUT); // for debugging Serial.begin(9600); // VirtualWire setup vw_setup(2000); // Bits per sec }void loop { length = 0; while(Serial.available ) { MsgcharAR(length) = Serial.read ; length++; delay(100); data_available = 1; }// Convert integer data to Char array directly // itoa(data,Sensor1CharMsg,10); if(data_available == 1) { // DEBUG Serial.print(" Sending data : "); Serial.println(MsgcharAR); //Serial.println(" "); delay(1000); // END DEBUGdigitalWrite(13, true); // Turn on a light to show transmitting vw_send((uint8_t *) MsgcharAR, length); vw_wait_tx ; // Wait until the whole message is gone digitalWrite(13, false); // Turn off a light after transmission delay(200); for(i = 0 ; i < 40 ; i++) { MsgcharAR (i) = 0; }} } // END void loop... #include// LED's int ledPin = 13; // Sensors int Sensor1Data; // RF Transmission container char Sensor1CharMsg(4); void setup { Serial.begin(9600); // sets the digital pin as output pinMode(ledPin, OUTPUT); // VirtualWire // Initialise the IO and ISR // Required for DR3100 vw_set_ptt_inverted(true); // Bits per sec vw_setup(2000); // Start the receiver PLL running vw_rx_start ; } // END void setupvoid loop { uint8_t buf(VW_MAX_MESSAGE_LEN); uint8_t buflen = VW_MAX_MESSAGE_LEN; void loop { uint8_t buf(VW_MAX_MESSAGE_LEN); uint8_t buflen = VW_MAX_MESSAGE_LEN; // Non-blocking if (vw_get_message(buf, &buflen)) {int i; // Turn on a light to show received good message digitalWrite(13, true); // Message with a good checksum received, dump it. for (i = 0; i < buflen; i++) { // Fill Sensor1CharMsg Char array with corresponding // chars from buffer. Sensor1CharMsg(i) = char(buf(i)); }data_available = 0; for(i = 0 ; i < 40 ; i++) { MsgcharAR (i) = 0; } } } // END void loop...
###
Diagramas de circuito
| RF22_0 |  |
Vídeo do projeto
