Arduino RF Link

Fra Kommunikation-IT Holstebro HTX
Skift til: navigering, søgning
Modul til sending af 433 MHz radiosignal
Modul til modtagelse af 433 MHz radiosignal

RF_link modulet er baseret på to billige moduler der kan købes sammen i Kina f.x. ved denne nethandel[1]

Modulet er udviklet uden at kigge på databladet, men blot ved at gætte sig frem omkring de betegnelser der er på printet, hvor man kan se hvor den skal have stel og +5V, og hvor data skal ind/ud.

Det er ikke så let at finde egentlige data på enhederne, men der ligger lidt på sendermodulet [2], godt nok i en 315 MHz version, men der er ikke den store forskel.

Modtagermodulet er fundet på en lidt sjov side [3], men man kan læse hvilke data den burde overholde.

Grundlæggende set er der ikke den store forskel på om man anvender et 315 MHz modul, et 433 MHz modul eller et med en helt tredje frekvens - man skal blot sikre sig at sender og miodtager arbejder på samme frekvens.

Princip for RF_link

Opbygningen af RF_link består af to hardware-moduler: et sendermodul med en tilhørende software og et modtagermodul med en tilhørende software. De to moduler skal være indstillet til samme frekvens, hvor de viste moduler arbejder på 433 MHz.

Sender-modul

Opbygningen af sendermodulet er en færdig opbygget oscillator, der arbejder på 433 MHz, hvor man ved hjælp af en transistor styrer om oscillatoren skal være tændt eller slukket ved hjælp af en transistor på modulet. Styringen sker ved hjælp af databenet, hvor det skal have 5V for at sende og 0V for at være slukket.

Ben Navn Betydning Arduino-ben
1 GND Stel GND
2 Vcc +5V forsyning 5V
3 Data Sende signal - når den er høj, sendes 433 MHz Valgfrit 4-13

Modtager-modul

Modtagermodulet består af en diskret opbygget modtager omkring to transistorer og en svingningskreds hvor der indgår en trimmekondensator som er afstemt til den ønskede frekvens. Herefter bliver signalet ensrettet og sammenlignet med et niveau, så modulet giver høj ud når det modtager noget på den ønskede frekvens, og det giver lavt niveau ud når der ikke modtages noget.

Sammenligningen foretages med en LM358 comperator inde i modulet.

Ben Navn Betydning Arduino-ben
1 GND Stel GND
2 Data Det modtagne signal - høj, når der modtages 433 MHz Valgfrit 2-3 kant-interrupt
3 Data Samme signal Valgfrit 2-3 kant-interrupt
4 Vcc +5V forsyning 5V

Specifikationer for RF_link

Specifikationerne er sakset fra de hjemmesider det har været muligt at finde, som dokumenterer funktionen.

Sender modul[2]
Parameter Data
Forsynings spænding 2.5V - 12V DC (nom. 5V)
Krævet forsynings-strøm 4mA @ 5V, 15mA @ 9V
Hvile-strømforbrug 10 uA
Modulationsform ASK
Temperatur område -10 til 60 grader C
Maks datarate 9600 k Baud
Data input TTL niveau (0/5V)
Output effekt 20 mW @ 5V


Modtager modul[3]
Parameter Data
Forsynings spænding 3V - 8V DC (nom. 5V)
Krævet forsynings-strøm < 3mA @ 5V
Modtage frekvens 315 / 433 MHz (433 MHz i vores version)
Frekvens område 260 - 440 MHz justerbart (undlad dette)
Modulationsform ASK / OOK
RF følsomhed -105 dBm (50 Ω)
Data rate < 5 kbps (315 MHz, -95 dBm)
Temperatur område -20 til 70 grader C
Data output TTL niveau (0/5V)
Antenne længde 24 cm (315 MHz), 18 cm (433,92 MHz)

Teori for RF_link modulet

Der er ikke så meget teori for RF_link modulet, da det princip der udnyttes blot er at transmittermodulet kan styres til at lave en frekvens på 433 MHz som den sender, eller der kan slukkes for den, så den ikke sender noget. Modtagermodulet giver så et højt signal ud når den modtager 433 MHz og et lavt når den ikke modtager noget.

For at teste om der er "hul igennem" på det helt simple plan, så er der lavet et lille program, der ligger i test_sender, og som består af følgende kode

const byte tx_pin = 13;
const byte kontakt = 4;

#define tid 37

void setup() {
  pinMode(tx_pin, OUTPUT);
  pinMode(kontakt, INPUT);
  digitalWrite(kontakt, HIGH);   // Lav pullup på kontakten
  Serial.begin(9600);
}

bool state = false;

void loop(){
  state = ! state;
  digitalWrite(tx_pin, state);
  if (digitalRead(kontakt)) {
    delayMicroseconds(tid);      // Puls og pause på ca. 47 us
  } else {
    delayMicroseconds(3 * tid);  // Puls og pause på ca. 127 us
  }
}

Ved at sætte forsyning på modtageren kan man måle med et oscilloscop hvordan modtageren reagerer.

Med et en frekvens på ca. 10 kHz (47 us puls og 47 us pause) vil det svare til en bitrate på 20.000 bit/sekund, her kan man se at puls og pause ikke modtages ens, som vist her:

Rf-send1.png
Måling med 47 us puls-tid og 47 us pausetid

Denne forskel kan blive problematisk, hvis man ønsker at kommunikere så hurtigt. I den videre udvikling nedsættes hastigheden for at lette transmissionen.

Hvis man i stedet sender med 127 us puls og pause, så bliver det modtagne signal noget tættere på en 50% duty-cycle, som det kan ses her:

Rf-send2.png
Måling med 127 us puls-tid og 127 us pausetid

Praktiske problemer ved transmission

Ved modtagelsen er man nødt til at tage højde for at der kan være en del støj ved modtageren. Det viste sig ved test at det hjalp en hel del at anvende ekstern forsyning, for at fjerne noget af støjen.

Hvis man ikke opbygger softwaren robust, så kan man kan miste enkelte pakker, fordi man misforstår noget af støjen som en del af en pakke.

Rf-modt2.png
Måling på modtager-siden mellem pakkerne, der viser støjpulser

For at teste robustheden af softwaren er en del af testen foretaget ved at bruge forsyning via PC-USB, hvor man så får væsentligt mere støj.

I den endelige version er modtagelsen er alligevel så robust at over halvdelen af pakkerne kommer uskadt igennem.

Rf-modt3.png
Måling på modtagersiden mellem pakkerne, når man bruger PC-USB som forsyning

Praktiske overvejelser ved at modtage pakken

Når man måler på støjpulserne ved modtageren, så kan de have mange forskellige længder, så det kan ikke lade sig gøre at fastlægge en bestemt bit-længde der er garanteret støjfri.

Når man sender til modtageren, så indstiller modtageren sig på det niveau den modtager på, men umiddelbart efter vil den igen være følsom over for tilfældig støj, som det kan ses på følgende måling, hvor den røde kurve er senderen og den blå kurve er modtageren.

Rf-link-kom1.png
Måling af støj omkring pakkerne, når man bruger PC-USB som forsyning

Som det kan ses kommer indholdet af selve pakken fint igennem, og er rimeligt "rent", men der er støj der naturligt nok ligger helt op til starten af pakken, og som opstår igen et stykke tid efter pakken - dette betyder at pauserne i en pakke ikke må blive for lange. Det betyder at vi ikke kan kommunikere med for langsom en bit-rate, og som det er illustreret før kan vi heller ikke sende for hurtigt.

Umiddelbart viser erfaringerne fra målingerne at pauserne gerne skal ligge mellem 80 us og 500 us for at støjen ikke skal få for meget indflydelse.

Princippet for at kommunikere en bit

Umiddelbart ville det være nemmest at tolke modtaget høj som 1 og modtaget lav som 0, men som det kan ses ville det give problemer hvis der i ens data ligger mange 0-bit efter hinanden, så ville pausen blive for lang.

Derfor vælges et princip inspiretet i hvordan en DHT11 luftfugtighedsføler kommunikerer. Den har kodet så 1-bit sendes som en lang høj puls og 0-bit sendes som en kort høj puls, og for at kunne aflæse længden af pulsen sendes der så en lav puls med en fast længde efter hver bit.

Ved at man i modtagelsen sætter maks. og min. for hvad en 1-bit, en 0-bit og en pause er, så vil man kunne identificere hvad der er indhold i en pakke og hvad der bare er tilfældig støj.

Rf-link-kom2.png
Måling af sending og modtagelse af 4 bit - 2 1-bit og 2 0-bit

I den viste måling startes med en 1-bit (lang høj og kort lav), derefter kommer en 0-bit (kort høj og kort lav) og de gentages derefter.

Den røde kurve er senderen og den blå er modtageren, og som det kan ses, så er alle tiderne ikke helt ens, men der vil sagtens kunne kendes forskel i modtagelsen.

Princippet i at finde starten på en pakke

En pakke består grundlæggende blot af en række bits sendt efter hinanden, så for at kunne forstå pakken, så skal man kunne finde ud af hvornår man skal begynde at læse i bit-strømmen.

Dette kan gøres ved at man sender en høj puls der er noget længere end en normal 1-bit og en pause der er længere end de normale pauser i starten af en pakke, som det er illustreret her under:

Rf-link-kom3.png
Måling af sending og modtagelse af starten af en pakke

Som det kan ses, så kommer der lidt tilfældig støj på modtagelsen (blå) inden pakken kommer, men det ser ikke ud til at forstyrre selve pakken, og man vil tydeligt kunne identificere den lange puls og den lange pause som starten af en pakke.

Nogle gange vil man dog få problemer med den lange puls som det ses ved en måling her:

Rf-link-kom4.png
Måling af sending og modtagelse af problematisk start af en pakke

Her modtages der støj som tolkes som høj mens pakken starter, og dermed er den lange start af pakken helt forkert.

For at modvirke dette kan man "indstille" modtageren på det rigtige signal-niveau ved at sende 3 relativt korte høj-lav inden starten af pakken angives med en lang høj og en lang lav. Dette er illustreret ved følgende måling:

Rf-link-kom5.png
Løsning på modtagelse af problematisk start af en pakke

Som det kan ses, så er de 3 gange høj der sendes forskellige fra både en 1-bit og en start-pakke i tid. Grunden til dette er hvis den første høje falder sammen med så meget støj at det svarer til en start-pakke, så er der lige tid til at modtageren kan forkaste de næste bit, og give sig til at lede efter en ny start på pakken, når den rigtige kommer lige efter.

Disse tests er udført ved hjælp af koden inde i Test_Sender der ligger med ZIP-filen der skal lægges ind i Arduino /libraries, så den kan hentes som eksempel.

Fastlæggelse af princippet for RF_link sending

For at udvikle en transmission, der kan overføre data korrekt, så opbygges der en datapakke ud fra følgende principper:

  • Inden pakken sendes kommer der 3 skæve bit hvor det er 100 us højt
  • Pakken starter med en marker på 300 us sending og en lang pause på 250 us
  • Der sendes en adresse, for at kunne sende til flere modtagere
  • Efter adressen sendes det inverterede, for sikre at pakken går godt
  • De ønskede byte sendes
  • Der sendes det inverterede af de ønskede bytes efter hver byte, igen for at sikre at data kommer korrekt over
  • Alle bytes tælles sammen (både adresse, ønskede bytes og alle de inverterede) til en check-sum der sendes til sidst
  • Der sendes med mindst betydende bit først
  • En 0-bit sendes som 50 us højt efterfulgt af 80 us lavt
  • En 1-bit sendes som 150 us højt efterfulgt af 80 us lavt

Sendingen efter disse principper, som også går igen i den endelige version er implementeret i RF_link.cpp og en samlet sending ser ud som følger:

Rf-link-kom6.png
Sending af en samlet pakke med start, marker og 5 bytes

Pakken tager totalt ca. 9 ms at sende som vist.

De 5 bytes består af byte med en adresse efterfulgt af den inverterede for at sikre at det modtages korrekt, derefter en byte med data og igen den inverterede for sikkerhed i modtagelsen og til slut checksummen for yderligere kontrol af om pakken er modtaget korrekt.

Adressen sendes for at kunne identificere hvilken enhed man sender til, og data er for at kunne sende noget konkret indhold – de to bytes kan ikke forveksles, da de altid kommer i den rækkefølge efter en marker på 1 ms.

Byten sendes med mindstbetydende bit først, og et 0 er kodet som ca. 50 us høj og 80 us lav, mens et 1 er kodet som ca. 150 us høj og 80 us lav, så det er let at se forskel på dem i modtagelsen. Ved at der først sendes en byte og derefter den inverterede vil der altid sendes 8 lav og 8 høj, så pakketiden er konstant.

Herunder ses en måling hvor man kan se slutningen af markeren efterfulgt af 9 bit. Første bit er høj, de næste 4 bit er lave, næste igen er høj og de to sidste bit der hører til byten er lave, og da mindst betydende bit sendes først, så er adressen udtrykt binært 0010_0001, hvilket svarer til 33, som det også kan ses i test_tx_byte.

Rf-link-kom7.png
Slutningen af skæve bit efterfulgt af marker og den første byte (adressen)

Simpel anvendelse af RF_link

For at kunne foretage en transmission med forskellige værdier kan man opbygge et sender-program der tæller en byte op for hver pakke der sendes. Det kunne gøres med følgende kode, der ligger i text_tx_byte:

#include "RF_link.h"

byte test = 2;

void setup() {
  LINK.tx_begin(13, 1);  // Initialiser sending på ben 13, pakkestørrelse 1 byte
  Serial.begin(9600);
}

void loop(){
  delay(300);
  Serial.print("P");
  Serial.print(" ");
  LINK.sendByte(33, test++);
  Serial.println();
}

Koden er lavet så den modtager byten og skriver den ud på den serielle monitor.

Dette ligger i koden test_rx_byte:

#include "RF_link.h"

void setup() {
  LINK.rx_begin(33, 0, 1);  // Adresse 33, Interrupt 0 (pin 2), 1 byte i pakken
  Serial.begin(9600);
}

void loop(){
  Serial.println(LINK.readByte());
  delay(100);
}

Dette forudsætter at alle pakker modtages korrekt, hvilket det ikke kan garanteres at de gør, men dette er blot et simpelt eksempel på en anvendelse, hvor man godt kunne leve med at der smutter nogle bytes.

Softwaren med test_tx_byte og test_rx_byte kan hentes i denne ZIP-fil. ZIP-filen pakkes ud inde i "C:\Program Files (x86)\Arduino\libraries" og ved at genstarte Arduinoprogrammet kan man hente alle eksemplerne i Fil - Eksempler - RF_link.

Software modulet RF_link

Modulet indeholder både sender-software og modtager-software, hvilket man vælger ud fra hvilke rutiner man anvender. Modulet er ikke testet med både anvendelse af sending og modtagelse, men der er ting som kunne gå galt, specielt hvis man skifter pakke-størrelse.

Hele softwaren er implementeret som et modul der lægges ind i Arduinos biblioteker, hvor den aktive kode er lavet i RF_link.cpp og interfacet til modulet er lavet i RF_link.h, der skal includes for at anvende modulet.

Rutiner til at sende med:

#include "RF_link.h"

void LINK.tx_begin(txPin, pakkeSize);
void LINK.send(adr, buffer);
void LINK.sendByte(adr, data);

Rutiner til modtagelse:

#include "RF_link.h"

void LINK.rx_begin(adr, intNr, pakkeSize);
bool LINK.available();
void LINK.read(buffer);
byte LINK.readByte();

Interface-fil til RF_link

I interface-filen RF_link.h ligger definitioner til både sende-modulet og modtager-modulet. Begge dele skal ligge der for at modulet kan fungere, men det er kun den ene del der oversættes, afhængigt af hvilken del man vælger.

Den første definition er den maksimale pakkestørrelse man kan modtage.

Resten er de tider i mikrosekunder som transmissionen arbejder med.

#define RF_bufferSize 16

#define RF_marker 300
#define RF_marker_low 250
#define RF_marker_high 400

#define RF_space 250
#define RF_space_low 200
#define RF_space_high 300

#define RF_bit_start 100

#define RF_bit_0 50
#define RF_bit_0_low 30
#define RF_bit_0_high 80

#define RF_bit_1 150
#define RF_bit_1_low 130
#define RF_bit_1_high 180

#define RF_pause 80
#define RF_pause_low 20
#define RF_pause_high 150

Tiderne er definere så der f.x. sendes en marker på 300 us, og i modtagelsen accepteres den fra 250 til 400. Tilsvarende med alle de andre tider.

Demo-eksempler til RF_link

Der er lavet 2 demo-eksempler som illustrerer hvordan modulet RF_link fungerer når man vil sende flere bytes. Der er koderne test_tx og test_tx, der kan hhv. sende og modtage en pakke med 4 bytes.

Koden i test_tx ser ud som følger:

#define pakkeSize 4

byte txPakke[pakkeSize];
byte test = 2;

void setup() {
  LINK.tx_begin(13, pakkeSize);
  Serial.begin(9600);
}

void loop(){
  txPakke[0] = 47;
  txPakke[1] = 12;
  txPakke[2] = 73;
  txPakke[3] = test++;
  LINK.send(33, txPakke);
  delay(300);
  Serial.print("P");
  Serial.print(" ");
  Serial.println();
}

Koden i test_rx ser ud som følger:

#define pakkeSize 4

byte rxPakke[pakkeSize];

void setup() {
  LINK.rx_begin(33, 0, pakkeSize);
  Serial.begin(9600);
}

void loop(){
  if (LINK.available()) {
    LINK.read(rxPakke);
    for (int n = 0; n < pakkeSize; n++) {
      Serial.print(rxPakke[n]);
      Serial.print(" ");
    }
    Serial.println();
  }
  delay(100);
}

Modtage-demoen fungerer ved at den ser om der er modtageten pakke, og hvis der er det, så skrives indholdet af pakken ud.

Sender-demoen tæller en byte op for hver pakke der sendes.

Modtage-demoen viser følgende seriel monitor-vindue:

Rf-link-modtager.png
Monitor-visning af modtagelse

Som det kan ses er det ikke alle pakker der kommer igennem. Det er man nødt til at leve med, eller selv sørge for at der bliver gensendt, hvis det er vigtigt at pakken kommer igennem.

Opbygningen af sendingen

Princippet i at sende en byte er relativt simpelt, da det er baseret på aktivt venten i koden, så de 9 ms det tager at sende en marker og de 5 byte sker aktivt i sende-rutinen, og der returneres ikke før hele byten er sendt.

Sendingen er opbygget ud fra følgende pseudokode:

Send 3 skæve bits
Send en marker
Send adressen
Send det inverterede af adressen
Send data
Send det inverterede af data
Send tjeksum

Dette er implementeret ved hjælp af følgende kode:

void RF_link::send(byte adr, byte buf[])
{
  byte CS = 0;
  
  for (int n = 0; n < 3; n++) {
    digitalWrite(tx_pin, HIGH);
    delayMicroseconds(RF_bit_start);
    digitalWrite(tx_pin, LOW);
    delayMicroseconds(RF_pause);
  }
  digitalWrite(tx_pin, HIGH);
  delayMicroseconds(RF_marker);
  digitalWrite(tx_pin, LOW);
  delayMicroseconds(RF_space);
  txByte(adr);
  CS = adr;
  txByte(byte(~adr));
  CS += byte(~adr);
  for (byte n = 0; n < bytesInPackage; n++) {
    txByte(buf[n]);
    CS += buf[n];
    txByte(byte(~buf[n]));
    CS += byte(~buf[n]);
  }
  txByte(CS);
}

Det at sende en byte er implementeret ved hjælp af følgende pseudokode:

Løb gennem alle 8 bit
   send lav i 80 us
   hvis aktuel bit er 0
      send høj i 50 us
   ellers
      send høj i 150 us
   skift til næste bit

Dette er implementeret ved hjælp af følgende kode:

void RF_link::txByte(byte data) {
  for (int n = 0; n < 8; n++) {
    digitalWrite(tx_pin, HIGH);
    if ((data & 0x01) > 0) {
      delayMicroseconds(RF_bit_1);
    } else {
      delayMicroseconds(RF_bit_0);
    }
    digitalWrite(tx_pin, LOW);
    delayMicroseconds(RF_pause);
    data /= 2;
  }
}

Opbygningen af modtagelsen

Hele modtagedelen er opbygget omkring et interrupt, hvor man anvender det kanttriggede interrupt af port ben 2 og 3 som er knyttet til interrupt 0 og 1. Til udmåling af tiderne anvendes den indbyggede funktion micros() der returnerer antal mikrosekunder siden start.

Selve det at modtage pakken sker ved hjælp af følgende kode:

void RF_link::read(byte buf[])
{
  while (! pakkeReady) delayMicroseconds(100);  // lock until package is fully received
  for (byte n = 0; n < bytesInPackage; n++) {
    buf[n] = buffer[n];
  }
  pakkeReady = false;
}

Selve tidsregistreringen sker i interruptet, men ikke ved hjælp af timer-interrupt, men derimod med den indbyggede funktion micros() der returnerer antal mikrosekunder siden start, så hver gang gemmes dens resultat, så man hele tiden måler tiden mellem hver kant.


Dette er implementeret med følgende kode:

void RF_link::interrupt_service() 
{
  timeSpent = micros() - lastTime;
  lastTime = lastTime + timeSpent;
  switch (mode) {
    case 0: // Venter på 300us puls
      lastTime = micros();
      if (digitalRead(rx_pin) == HIGH) {
        mode = 1;
      }
      break;
    case 1: // Har modtaget 300us puls og vil vente på 250us pause hvis det var inden for rammerne af 300us
      if (timeSpent > RF_marker_low && timeSpent < RF_marker_high) {
        mode = 2;
      } else {
        mode = 0;
      }
      break;
    case 2: // Har modtaget 250us pause vil vente på bits hvis det var inden for rammerne af 250us
      if (timeSpent > RF_space_low && timeSpent < RF_space_high) {
        mode = 3;
        bitNr = 0;
        byteNr = 0;
        CS = 0;
      } else {
        mode = 0;
      }
      break;
    case 3:
    case 4:
      if (digitalRead(rx_pin) == LOW) {
        if (timeSpent > RF_bit_0_low && timeSpent < RF_bit_0_high) {
          inputBits /= 2;
        } else {
          if (timeSpent > RF_bit_1_low && timeSpent < RF_bit_1_high) {
            inputBits /= 2;
            inputBits += 0x80;
          } else {
            mode = 0;
          }
        }
        bitNr++;
        if (bitNr == 8) {
          rxByte = inputBits;
          if (byteNr == bytesInPackage) {
            if (inputBits == CS) {
              // Her afsluttes pakken
              pakkeReady = true;
            }
            mode = 0;
          }
          CS += inputBits;
          inputBits = 0;
        }
        if (bitNr == 16) {
          if (rxByte == byte(~inputBits)) {
            CS += inputBits;
            if (mode == 3) {
              if (rxByte == rx_address) {
                mode = 4;
                pakkeReady = false;
                bitNr = 0;
              } else {
                mode = 0;
              }
            } else {              
              buffer[byteNr] = rxByte;
              byteNr++;
              bitNr = 0;
            }
          } else {
            mode = 0;
          }
        }
      } else {
        if (timeSpent > RF_pause_low && timeSpent < RF_pause_high) {
          ;
        } else {
          mode = 0;
        }
      }
      break;
    default:
      mode = 0;
  }
}

Koden fungerer efter en state-machine, hvor state 0 venter forkanten af en høj puls - hvis den kommer går man i state 1.

I state 1 registreres ved et kantskifte om den høje puls var ca. 300 us lang. Hvis godkendes går man til state 2, ellers tilbage til state 0. På denne måde markeren som starten af pakken, og hvis noget går galt i en modtagelse, så ender man her igen, og kigger efter en ny start af pakken.

I state 2 ser man efter om pausen efter en marker er 250us, og hvis den er det går man videre til state 3.

I state 3 og 4 modtages bits. Længden af de lave pauser kontrolleres til at være omkring 80 us og de høje pulser kontrolleres til at skulle være enten 50 eller 150 us. Hvis nogen af disse tider fejler går man tilbage til state 0 for at modtage pakken forfra.

Ud fra om det er 50 eller 150 us bliver det gemt i en byte som en 0-bit eller en 1-bit.

Når der er modtaget 8 bit, så gemmes resultatet, og når der er modtaget 16 bit sammenlignes de første 8 bit med om de svarer til de næste 8 inverteret, hvis dette går godt accepteres byten.

I state 3 sammenlignes byten med den adresse der blev angivet ved initialiseringen, og hvis det er i orden, så sættes state til 4, ellers går man bare til state 0.

I state 4 gemmes byten i bufferen.

Alle korrekte modtagne bytes lægges sammen til en tjeksum. Når man har modtaget 8 bit og har fyldt det i pakken man skal, så er det tjeksummen der modtages, og hvis den passer med den tjeksum man har regnet sig frem til ud fra resten af det modtagne, så registreres der at der er modtaget en gyldig pakke.

Alle kodeeksempler ligger samlet i en ZIP-fil

Simpel test af rækkevidde

For at teste hvordan rækkevidden er, så er senderen blevet placeret to etager over modtageren, så der skal transmitteres gennem to etageadskillelser, hvilket normalt ville dæmpe signalerne væsentligt. For at optimere er der monteret ca 18 cm antenne på både sender og modtager. Både sender og modtager forsynes med ekstern forsyning, for ikke at bidrage med ekstra støj.

I denne konfiguration gik alle pakker igennem ved en test over 256 pakker.

Hvis det kun er senderen der har monteret antenne, så går ca. 220 ud af 256 pakker igennem.

Hvis modtageren forsynes med PC-USB, så reduceres antallet af pakker der kommer igennem til ca. 6 ud af 256 uden antenne på modtageren, og dette kan igen forbedres ved hjælpe af en antenne på modtageren, så der kommer ca. 16 igennem ud af 256.

Andre versioner af RF_link hardware

Man kunne bygge sit eget modul, men det er normalt ikke tilrådeligt, da det kan være svært at sikre sig at man ikke sender noget på uønskede frekvenser, hvilket kan forstyrre anden kommunikation, som kan være kritisk (f.x. flykommunikation).

Men som nævnt er disse moduler blot nogen af de versioner der kan anvendes - det der er kravet til dem er faktisk at de skal være simple. Det skal forstås sådan at senderen bare skal afsende radiobølge på en frekvens når den får højt signal og lade være når den får lavt signal - tilsvarende skal modtageren give højt signal ud når den modtager noget med frekvensen og lavt signal når den ikke modtager noget.

Alternativer til RF_link softwaremodulet

En anden måde at opbygge kommunikationen på er ud fra følgende modul[4], som ligeledes etablerer en virtuel forbindelse via et sender og et modtager modul.

Et andet alternativ til Arduino, er et eksempel på den her[5].

Referencer

  1. Kinesisk netshop med dansksproget visning
  2. 2,0 2,1 Side der beskriver FS1000A
  3. 3,0 3,1 En hjemmeside af uforståelig sproglig herkomst, men med noget indhold der kan tydes som modulet - og dets data
  4. Side med Arduino Virtual Wire
  5. Side med eksempel på anvendelse af sender og modtager