I would like to get the best range possible from my 433MHz modules. After A LOT of searching and reading, I'm convinced I should be able to cover 10m indoors with free line of sight.

[update]
After some tips in the comments I changed a few things. It looks like with an Arduino receiving in stead of a Pi, I get an extra meter, 1,5m now so still terrible. And 'as a bang on the fire arrow' as we say in Dutch, I now use two whip antenna's parallel to each other.
Before moving to fix the reception on my Pi, I now first try to maximize the reception on the receiving Arduino. This makes it much more simple to investigate.

[update 2]
After some more tests I got to about 6 meters range. When the transmitter is behind 1cm of wood, this goes back to 30cm.
My current 433MHz modules are going into the garbage bin, I thank you all for your time. I will look for a more stable alternative and maybe try some other/better433MHz modules like these: http://www.ebay.com/itm/433MHz-Superheterodyne-RF-Link-kits-3400-ARM-MCU-Transmitter-and-Reveiver-/281169560721?hash=item4177030491:g:SUcAAOxyaTxTRKJn

[update 3]
The new modules made an enormous change. I can now send my data from across my house with no problems at all. No ground plane (will try that TwoD!) yet. Still on 5V transmitter voltage!

I've asked a question before about my 433MHz setup so for full disclosure:
433MHz sending not receiving

My current range is about 40/50cm, this is not much since I use a straight antenna ~17cm at the receiver and a coil antenna at the transmitter:
http://www.instructables.com/id/433-MHz-Coil-loaded-antenna/

These are the modules I use:
http://www.ebay.com/itm/-/221524421949?roken=cUgayN&soutkn=xKBBUo

And just FYI, I use these awesome working pumps:
http://www.ebay.com/itm/-/321779742264?roken=cUgayN&soutkn=hk1lrB

I have tried many antenna combinations and also upping the transmitter voltage to 12V but it doesn't help much. My aim is to reach 10m line of sight at the least.

  • I notice that my Pi outputs 4.77V to the receiver.
  • The 4 penlites now output around 5V so transmitter power is low.
  • What I also like to test is adding 10uF caps to the V and GND of the transmitter but I have to wait for them to get delivered.
  • I have the 10mw version of the transmitter, they may be just useless.
  • The receiver stands in front of a speaker and a subwoofer, I turn those off when I test.
  • The 433MHz modules came in pairs. I did not respect this and use any receiver with any transmitter, wonder if this is a problem. My end-goal is 3 transmitters on one receiver.
  • Since I have multiple Tx/Rx modules, I swapped them to exclude DOA modules.
  • Also tried these Helical antenna's, only made range worse; http://www.ebay.com/itm/-/171271811976?roken=cUgayN&soutkn=TmOnpH

My Arduino usses VirtualWire to send with 1000 baud to my Raspberry Pi, on the Pi side I use PIGPIO and the following code:

if __name__ == "__main__":

   import time
   import datetime
   import pigpio
   import vw
   import json
   import requests
   from requests.auth import HTTPDigestAuth

   # Setup receiving 433MHz port
   RX=27

   # Setup Baud rate 433MHz
   BPS=1000

   # Connect to local Pi.
   pi = pigpio.pi() 

   # Specify Pi, rx gpio, and baud.
   rx = vw.rx(pi, RX, BPS) 

   # Empty message
   msg = 0

   # Save the time
   start = time.time()

   # Run for 3 seconds
   while (time.time()-start) < 36000:

      # Count msg per cycle
      msg += 1

      # Sleep for .4 second
      time.sleep(0.4)

      # Run while receiver is ready
      while rx.ready():

         # String join received characters into message
         message = ("".join(chr (c) for c in rx.get()))

         # Print the received message to screen
         print(message)

         # Create data dictionary
         data = {}
         data['meting']    = message[8:11]
         data['bericht']   = message[4:7]
         data['plant']     = message[1:3]
         data['timestamp'] = str(datetime.datetime.utcnow().isoformat())

         # Print the data to the screen
         print(data)

         # Setup filename for local data backup
         filename = str('data/' + data['plant'] + data['bericht'] + data['meting'] + '.json')

         # Write JSON data file to disk
         with open(filename, 'w') as outfile:
            json.dump(data, outfile)

         # Sending data
         url = 'http://server:8000/v1/documents?database=plantjes&extension=json'

         # Setup headers
         headers = {
            'Content-Type': 'application/json'
         }

         # Execute request
         r = requests.post(url, json = data, auth=HTTPDigestAuth('plantje', 'password'))

         # Print request response
         print r

   # Cancel the receiving of data
   rx.cancel()

   # Stop PIGPIO listening on pins
   pi.stop()

This script sends the measurement of the Hygro sensor to a database in JSON. This works like a charm.

The Arduino uses this code:

#include <VirtualWire.h>
#include <Sleep_n0m1.h>

String pid = "p02";
const int led_pin = 11;
const int transmit_pin = 12;
const int hygroSensor = 0;
int hygroPower = 8;
const int pump_pin = 5;
int watering_level = 900;

int count = 0;
Sleep sleep;
unsigned long sleepTime;

void setup()
{
  // serial console setup
  Serial.begin(9600);
  Serial.println("setting up");

  // cycle sleep time in ms
  sleepTime = 10000;

  // virtualwire setup
  vw_set_tx_pin(transmit_pin);

  // setting of pin modes
  pinMode(hygroPower, OUTPUT);
  pinMode(led_pin, OUTPUT);
  pinMode(pump_pin, OUTPUT);

  // Bits per sec
  vw_setup(1000);
}

void loop()
{
  // delay to allow serial output to be ready after wake up
  delay(100); 

  // cycle counter
  count++;

  // turn on hygro sensor module
  digitalWrite(hygroPower, HIGH);

  // wait a bit for hygro sensor to start
  delay(1000);

  // read the input on analog pin 0:
  int measure = analogRead(hygroSensor);

  // Start light to show transmitting
  digitalWrite(led_pin, HIGH); 

  // log moment of sending
  Serial.println("Sending: " + String(measure));

  // create & send random message id
  String mid = "m" + String(random(100, 999));

  // Sending data
  String hygrodata = "d" + String(measure);
  dataSend(pid + mid + hygrodata);

  // Stop light to show transmitting
  digitalWrite(led_pin, LOW);

  // Wait a second
  delay(1000);

  // sleep code
  if(count >= 3)
  {
    // reset counter
    count = 0;

    // run pump routine
    //waterpump(measure, mid, pid);

    // log sleeping to serial console
    Serial.print("Going to sleep now..");

    // set sleep mode
    sleep.pwrDownMode();

    // turn off hygro module power
    digitalWrite(hygroPower, LOW);

    // sleep for: sleepTime
    sleep.sleepDelay(sleepTime);
  }
}

// Data sending funtion
int dataSend(String data) {
  // declare int for length of message
  int msglen;

  // set length of message +1
  msglen = data.length() + 1;

  // declare array of characters
  char envelope[msglen];

  // put string in array
  data.toCharArray(envelope, msglen);

  // log data to serial monitor
  Serial.println(data);

  // send data
  vw_send((uint8_t *)envelope, sizeof(envelope));

  // wait for sending to finish
  vw_wait_tx();

  // return 1 for succes
  return 1;
}

// Pump function
int waterpump(int measure, String mid, String pid) {
    // Log measure
    Serial.println(measure);

    // Water when needed
    if (measure > watering_level) {
      // Turn on pump 2 seconds
      digitalWrite(pump_pin, HIGH);
      delay(3000);
      digitalWrite(pump_pin, LOW);
      // Send pump data
      dataSend(pid + mid + "pump");
    }
}

This controls the sensing of the messages and also the water pump I use to water my plant automagically when needed. This also works like a charm.

Arduino Hygo meter 433MHz setup Raspberry Pi 433MHz receiver

  • That "helping hands" antenna stand is highly suspect - did you model that as part of the antenna? It very much is, and probably not in a good way. Try holding the board with the antenna projecting, and possibly an opposing ground wire of the same length, radials, or a ground plane - depending on what the theory of how your chosen antenna is supposed to work is. That said, what is the usual range for these modules? – Chris Stratton Dec 17 '15 at 13:42
  • 2
    Have you tried receiving to an Arduino (with RX module) with serial printout to Pi? Just to compare the performance (assuming Pi is missing RX). I have several RF433/Arduino modules for sensor data transmitting over 5 m through up to three walls indoor (at 4000 bps, 3V7). This is with a modified version of VirtualWire with a Hamming(7,4) encoder with bit-error correction. Please see github.com/mikaelpatel/Cosa/blob/master/libraries/VWI/VWI.hh, github.com/mikaelpatel/Cosa/blob/master/libraries/… and github.com/mikaelpatel/Cosa-Domotica. – Mikael Patel Dec 17 '15 at 13:47
  • the helping hands are just for the photo :) so I didn't have them there while testing. the usual range is 1 wall + 10 meters or 50m outside with two straight antenna's. but this is Google science... – Thijs Dec 17 '15 at 14:59
  • 1
    I don't think you should combine helical and whip antennas. Also, building helical antennas requires a bit of precision in length, inner diameter, number of turns, spacing between turn, and probably more. I'd go with whip antennas on both sides, and make sure they are parallel to each other. I'd also experiment with the length of the antenna. Some people say you have to subtract the length of the little loop of wire already on the board. Just make it a bit to long, and keep cutting it shorter, and see what effects it has on range. Also more the units around; there may be dead spots. – Gerben Dec 17 '15 at 16:00
  • 1
    The PI might be generating a lot of "background noise". Might need to protect the TX module from that. – Mikael Patel Dec 17 '15 at 16:16

I've had the same problem, couldn't get past 2 meters range. Until i noticed that the TX-Frequency was off by about 150kHz. I adjusted the RX Frequency (the module has a trimmer) and now 40-50m is possible with a wall in between.

The 433mhz modules can be sensible on the power lines, place a cap on the power input. Also a straight antenna works most of the times, but if you want some more distance, look into making a dipole antenna, there is a coil loaded diy antenna you can make that helps a little bit up from straight wire.

  • thanks! I was just reading about that cap on the power input, how and why it works. Wondering how much uF and why.. – Thijs Mar 30 '16 at 7:33
  • 1
    I've used anything from 10uF and up, it's for power smoothing so the value is not critical. – Hans Neve Mar 30 '16 at 7:34

On the transmitting side (with cheap AC switches as receiver), I've actually had good results with the cheap green squares, and the equally cheap 5 for a dollar 'Helical antenna 433MHz' you find everywhere on ebay :) I can reach all three levels of our house with that, and that's with only 5v supply on the green square, and it just sitting on a breadboard.

On request, picture of the antenna, soldered onto one of the cheap green transmitters, this one works well for me on 5V:

Picture of antenna

This antenna was bought as a set of 5 from: http://www.ebay.com/itm/171271811976

There's about 21 windings, with 5mm diameter, so that makes roughly 5mm * 3.14(=Pi) * 21 = 33 cm of wire in the coil.

  • could you please attach a picture of the antenna? – Thijs Jul 30 '16 at 14:49
  • Done, see the answer – cranphin Jul 30 '16 at 15:05
  • Keep in mind they're specific to a frequency, you want ones sold specifically for 433mhz :) – cranphin Jul 30 '16 at 16:11

Have you ever tried the Nordic nRF24L01 based modules? They are available on eBay for very low cost, and operate in the 2.4 GHz band. They should offer a range of at least tens of meters indoors. I have had good success with these, and they are very easy to interface to Arduino.

  • I've ordered one of those to check it out! What I also have is an ESP8266 module but it seems to be more used as a stand-alone solution than as an Arduino module. Until the nRF24L01 is here, I'll be testing with that one. – Thijs Dec 18 '15 at 7:56
  • Yes, ESP8266 is better suited to connecting to a wireless router. The nRF chips are better suited to mesh-type networks. – Ryan Griggs Mar 30 '16 at 16:42

I have the same TX/RX modules and two Arduinos and can get pretty good transmission reliability all throughout my house but it took some experimenting to figure out the largest factors in play (for me).

Module pairs should not matter, I got my 5 pairs jumbled up in a plastic bag, think only one was DOA. I use them together with Nexa wireless electric outlets and remotes since they operate on the same frequency and give me a decent reference point.

One thing I've noticed about the [receiver] modules is that they tend to auto-adjust to the signal strength. Blast at them with a transmitter at close range for a while and they will become worse at picking out the signs, from the noise at long range for some time. This appears to be true of the 433Mhz Nexa devices too. When starting to transmit from further away, it may take longer before the receiver figures out it's found a signal. Remember, these modules output only 1 or 0, not an analog signal, so they have to decide which level of noise to accept as 0 and when there is a 1.

My first mistake was not using a well attached antenna. A simple piece of strong wire is good enough in itself, but only if it makes good contact with the module. Good soldering skills always recommended.

My second mistake was not giving the transmitter enough power. It can handle 12V, so give it 12V (not on the data pin!). Only go lower after you got it to work at the needed distance.

Try with a large ground plane for both transmitter and receiver (no contact with the device itself!). I got a very good range with my receiver on my computer case and the transmitter on my fridge!

I could even get a reliable reading from a temp sensor from inside the garage 10m away from the house when getting about 2m off the ground, using 17cm plain straight wires as antennas with good ground planes. (Monopoles antennas need ground planes to bounce the signal off.)

Try visualizing the signal on the receiving side with an oscilloscope. If you gave an analog receiver it's probably easier to tell apart noise and real data. But if all you got is the RX module, hooking up the data pin to some kind of logged visualization will at least let you see how difficult it is to spot the data patterns.

Try increasing the length of your preamble before the actual data. It'll let the receiver adjust before it gets to the interesting bits.

Repeat your transmitted data. Include a piece of id data which changes with each message, but not with each repetition, and store the last received id for comparison before relaying it to wherever.

Your Answer

 

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

Not the answer you're looking for? Browse other questions tagged or ask your own question.