A radio module for Raspberry Pi

Would you like to easily transfer some data with your Raspberry Pi, control your radio sockets, or receive information from a weather station?
But you don't want to heat up your soldering iron or have floating wires?

Then you are absolutely in the right place!

With Pi433 there finally is a simple add-on available, allowing you to extend your Raspberry Pi with a 433MHz sender and receiver in the twinkle of an eye. Pi433 can easily be plugged onto the GPIO header of your Raspberry.
Pi433 is so handy and small that it fits into nearly every case available for the Raspberry Pi.

Pi433 comes with an on-board antenna printed onto the PCB. The performance of this antenna is suitable for a lot of low-range tasks. If you need extended range, Pi433 can help you too. Besides the on-board antenna, Pi433 is equipped with an U.FL socket that you can use to attach an external antenna.

With Pi433 Raspberry Pis can communicate wirelessly with each other. In addition, Pi433 enables Raspberry Pis to communicate with third party devices, also using 433MHz radio. This makes it possible to switch radio sockets or receive data from other devices.

Sitemap

Pi433s Highlights
Technical Information
Connecting Pi433
Driving Pi433
Purchase Pi433
Contact details and imprint

Pi433s Highlights

  • Fits onto all derivates of Raspberry Pi series (on Pi zero, a header needs to be added)
  • Fits onto numerous other devices as well, as long as they are equipped with a Pi compatible GPIO header (e. g. Banana Pi, Orange Pi, ...)
  • Takes only 10 pins of the GPIO header - all other pins remain unassigned and can be used by you for other purposes
  • Supports receiving and transmitting functions
  • Supports several modulations (FSK, MSK, OOK)
  • Frequency freely adjustable within the 433MHz ISM band (433,05...434,79MHz)
  • Has a fifo, meaning data can be uploaded and then transferred without interaction of the Pi - no pin toggling needed
  • Has several extra features, such as preamble generation and detection, address filtering, AES, CRC, etc.)
  • Has a PCB antenna, suitable for low-range applications
  • Connectable external antenna via U.FL socket
  • Linux kernel driver integrated in official kernel source tree, starting with kernel 4.14
  • CE declaration of conformity available

Technical Information

Pi433 is equipped with a receiving and transmitting RFM69 module by HopeRf. The datasheet of the module is freely obtainable on the internet - e.g. here. You will find a detailed description of the module and its register set in the datasheet. The technical data mentioned there are almost entirely applicable for Pi433 as well:
  • +13 dBm Power Output Capability
  • High Sensitivity: down to -120 dBm at 1.2 kbps
  • High Selectivity: 16-tap FIR Channel Filter
  • Programmable Pout: -18 to +13 dBm in 1dB steps
  • FSK Bit rates up to 300 kb/s
  • Fully integrated synthesizer with a resolution of 61 Hz
  • FSK, GFSK, MSK, GMSK and OOK modulations
  • Built-in Bit Synchronizer performing Clock Recovery
  • Incoming Sync Word Recognition
  • 115 dB+ Dynamic Range RSSI
  • Automatic RF Sense with ultra-fast AFC
  • Packet engine with CRC-16, AES-128, 66-byte FIFO
  • Built-in temperature sensor
Pi433 connects the RFM69 to the SPI interface of the Raspberry Pi. Three digital I/Os DIO0, DIO1 and DIO 2 are also connected. The connection details are shown in the following table:

RFM69Raspberry Pi
DIO0GPIO24
DIO1GPIO25
DIO2GPIO7

Connecting Pi433

Pi433 can be directly plugged onto the GPIO header of the Raspberry Pi.

On a 2nd or 3rd generation Raspberry Pi and model B+, the module needs to be connected in the middle of the GPIO header. On the side of the network jack seven double-pins need to be left unconnected; on the other side eight double-pins are left unconnected.

On a 1st generation Raspberry Pi, the module needs to be connected flush to the edge of the GPIO header on the side of the RCA jack (video out).

Driving Pi433

Pi433 is controlled via the SPI interface. The register set and the usage of the registers is detailed in the datasheet of the RFM69CW module.

Below you'll find two sample codes, giving an idea of how to interface with Pi433. One snippet implements a simple sender, transmitting a 16 byte telegram every time a key is pressed. The other snippet implements a receiver. The receiver configures Pi433 exactly in the same way the sender does -it continuously listens for messages. These sample codes use several of the extra functions of the RFM69 to check for transmission errors: preamble generation/detection, sync word generation, and CRC.

the sample code of the sender.
/*
 * Pi433 tx demo
 *
 * Copyright (c) 2017 Marcus Wolf <marcus.wolf@wolf-entwicklungen.de>
 *
 * This program is free software; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License as 
 * published by the Free Software Foundation; either version 2 of
 * the License.
 *
 */

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>

#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

#define PAYLOAD_LEN 16

static void pabort(const char *s)
{
	perror(s);
	abort();
}

static	uint8_t bits = 8;
static	uint32_t speed = 500000;
static	uint16_t delay = 0;


static int setupRFParameters(int fd)
{
	int i, ret;

	uint8_t tx[] = {
	/* attention - do not modify this parameters */ 
	   unless you know what you do. 
	   Wrong settings may violate yapplicable law */
	0x81,0x04,	// set standby mode (just for safety)
	0x82,0x08,	// OOK, packet, no shaping
	0x91,0x9f,	// set up power amps
	0x98,0x08,	// antenna impedance (default: 50Ohm)
	0x87,0x6c,	// frequency
	0x88,0x7a,	// frequency
	0x89,0xe1,	// frequency
	0x83,0x1a,	// bit rate
	0x84,0x0a,	// bit rate
	0x85,0x00,	// deviation (FSK only)
	0x86,0x45,	// deviation (FSK only)
	0x92,0x09,	// pa ramp (default: 40µs)
	};

	for (i = 0; i < ARRAY_SIZE(tx); i+=2)
	{
		struct spi_ioc_transfer tr =
		{
			.tx_buf = (int)tx+i,
			.rx_buf = 0,
			.len = 2,
			.delay_usecs = delay,
			.speed_hz = speed,
			.bits_per_word = bits,
		};

		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message to \
					setup RF parameters");
	}
	printf("RF parameters set up\n");
}

static int setupMessageParameters(int fd)
{
	int i, ret;

	uint8_t tx[] = {
	0xBC,0x80,	// startup condition (fifo not empty)
	0xB8,PAYLOAD_LEN,	// payload length
	0xAC,0x00,	// preamble size
	0xAD,0x0a,	// preamble size
	0xB7,0x10,	// fixed length, CRC on, no adress filtering
	0xAE,0x98,	// sync pattern on, 3 bytes
	0xAF,0x01,	// 1st sync byte
	0xB0,0x02,	// 2nd sync byte
	0xB1,0x03,	// 3rd sync byte
	};

	for (i = 0; i < ARRAY_SIZE(tx); i+=2)
	{
		struct spi_ioc_transfer tr =
		{
			.tx_buf = (int)tx+i,
			.rx_buf = 0,
			.len = 2,
			.delay_usecs = delay,
			.speed_hz = speed,
			.bits_per_word = bits,
		};

		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message to setup \
					message parameters");
	}
	printf("message parameters set up\n");
}


static int transferData(int fd, unsigned int packetNr)
{
	int i, ret;

	uint8_t tx[] = {
	0x81,0x04, 	// stop transmission (in case stil active)
	/* load fifo */
	0x80,(packetNr & 0xff00) >> 8,
	0x80,packetNr & 0xff,
	0x80,0xAA,
	0x80,0x55,
	0x80,0x88,
	0x80,0x88,
	0x80,0x88,
	0x80,0x88,
	0x80,0x88,
	0x80,0x8E,
	0x80,0x8E,
	0x80,0x88,
	0x80,0x8E,
	0x80,0x8E,
	0x80,0x47,
	0x80,0x11,
	0x81,0x0c, 	// start transmission
	};

	for (i = 0; i < ARRAY_SIZE(tx); i+=2)
	{
		struct spi_ioc_transfer tr =
		{
			.tx_buf = (int)tx+i,
			.rx_buf = 0,
			.len = 2,
			.delay_usecs = delay,
			.speed_hz = speed,
			.bits_per_word = bits,
		};

		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message \
					to trasmit data");
	}
	printf("Transmission started\n");
}

int main(int argc, char *argv[])
{
	int i;
	int fd;
        int packetNr = 0;


	printf("*** Pi433 TX demo by Marcus Wolf ***\n");
	printf("Press enter to send further telegrams.\n");
	printf("Enter 'q' to quit\n\n");

	/* open and configure SPI interface */
	fd = open("/dev/spidev0.0", O_RDWR);
	if (fd < 0)
		pabort("can't open spi. Maybe you need to enable \
				spi by calling \"raspi-config\"");

	setupRFParameters(fd);
	setupMessageParameters(fd);

	do
	{
		transferData(fd,packetNr++);
		sleep(1); // wait for transmission to complete
	} while(getchar() != 'q');

	close(fd);

	return 0;
}
				
the sample code of the receiver.
/*
 * Pi433 rx demo
 *
 * Copyright (c) 2017 Marcus Wolf <marcus.wolf@wolf-entwicklungen.de>
 *
 * This program is free software; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License as 
 * published by the Free Software Foundation; either version 2 of
 * the License.
 *
 */

#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>

#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

#define PAYLOAD_LEN 16

static void pabort(const char *s)
{
	perror(s);
	abort();
}

static	uint8_t bits = 8;
static	uint32_t speed = 500000;
static	uint16_t delay = 0;


static int setupRFParameters(int fd)
{
	int i, ret;

	uint8_t tx[] = {
	/* attention - do not modify this parameters */ 
	   unless you know what you do. 
	   Wrong settings may violate yapplicable law */
	0x81,0x04,	// set standby mode (just for safety)
	0x82,0x08,	// OOK, packet, no shaping
	0x91,0x9f,	// set up power amps
	0x98,0x08,	// antenna impedance (default: 50Ohm)
	0x87,0x6c,	// frequency
	0x88,0x7a,	// frequency
	0x89,0xe1,	// frequency
	0x83,0x1a,	// bit rate
	0x84,0x0a,	// bit rate
	0x85,0x00,	// deviation (FSK only)
	0x86,0x45,	// deviation (FSK only)
	0xA9,0x90,	// RSSI threshold
	0x9B,0x43,	// OOK threshold
	0x99,0x90,	// bandwidth configuration
	0x9A,0x90,	// bandwidth configuration
	0xEF,0x00,	// continuous Dagc in normal mode
	};

	for (i = 0; i < ARRAY_SIZE(tx); i+=2)
	{
		struct spi_ioc_transfer tr =
		{
			.tx_buf = (int)tx+i,
			.rx_buf = 0,
			.len = 2,
			.delay_usecs = delay,
			.speed_hz = speed,
			.bits_per_word = bits,
		};

		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message \
					to setup RF parameters");
	}
	printf("RF parameters set up\n");
}

static int setupMessageParameters(int fd)
{
	int i, ret;

	uint8_t tx[] = {
	0xBC,0x80,	// startup condition (fifo not empty)
	0xB8,PAYLOAD_LEN,	// payload length
	0xAC,0x00,	// preamble size
	0xAD,0x0a,	// preamble size
	0xB7,0x10,	// fixed length, CRC on, no adress filtering
	0xAE,0x98,	// sync pattern on, 3 bytes
	0xAF,0x01,	// 1st sync byte
	0xB0,0x02,	// 2nd sync byte
	0xB1,0x03,	// 3rd sync byte
	};

	for (i = 0; i < ARRAY_SIZE(tx); i+=2)
	{
		struct spi_ioc_transfer tr =
		{
			.tx_buf = (int)tx+i,
			.rx_buf = 0,
			.len = 2,
			.delay_usecs = delay,
			.speed_hz = speed,
			.bits_per_word = bits,
		};

		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message to \
					setup message parameters");
	}
	printf("message parameters set up\n");
}


static int receiveData(int fd)
{
	int i, ret;
	struct spi_ioc_transfer tr;
	struct data_struct {
		uint8_t reg;
		uint8_t value;
	};
	union data_union {
		struct data_struct strct;
		uint8_t array[2];
	} data;
	uint8_t rx[66];
	int messageLen;

	/* prepare tr struct */
	memset(&tr, 0, sizeof(tr));
	tr.tx_buf = (int)data.array;
	tr.rx_buf = (int)rx;
	tr.len = 2;
	tr.delay_usecs = delay;
	tr.speed_hz = speed;
	tr.bits_per_word = bits;

	/* start reception */
	data.strct.reg = 0x81; data.strct.value = 0x10;
	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
	if (ret < 1)
		pabort("can't send spi message to \
				start reception\n");

	/* wait for CRC ok */
	rx[1]=0x00;
	while( (rx[1] & 0x02) == 0 )
	{
		data.strct.reg = 0x28; data.strct.value = 0;
		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message to \
					read flag register\n");
	}

	/* read fifo */
	data.strct.reg = 0x00; data.strct.value = 0;
	for (i = 0; i < ARRAY_SIZE(rx); i+=2)
	{
		tr.rx_buf = (int)rx+i;
		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message to read fifo");
	}

	/* set standby mode */
	data.strct.reg = 0x81; data.strct.value = 0x04;
	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
	if (ret < 1)
		pabort("can't send spi message to switch to standby\n");

	/* every second value in buffer contains a valid value */
	for (i = 0; i < PAYLOAD_LEN*2; i+=2)
	{
		printf("0x%x ",rx[i+1]);
	}
	printf("\n");
}

int main(int argc, char *argv[])
{
	int i;
	int fd;
        int packetNr = 0;


	printf("*** Pi433 RX demo by Marcus Wolf ***\n");

	/* open and configure SPI interface */
	fd = open("/dev/spidev0.0", O_RDWR);
	if (fd < 0)
		pabort("can't open spi. Maybe you need to enable \
				spi by calling \"raspi-config\"");

	setupRFParameters(fd);
	setupMessageParameters(fd);

	/* receive */
	printf("entering endless loop to receive telegrams\n");

	while (1)
		receiveData(fd);

	/* these lines will never be reaced */
	close(fd);

	return 0;
}
				

Download the sample code of the sender.
Download the sample code of the receiver.

The next example illustrates how to control a radio socket. The example is written for sockets with PT2262 chipset (or compatible - e.g. HX2262 and SC5272) and needs to be adapted to work with other sockets. The sample code is optimized to work with a radio socket of type PFS-3 from Pollin electronics.

the sample code for controlling radio sockets.
/*
 * Pi433 socket demo (for sockets with PT2262 or compatible)
 *
 * Copyright (c) 2017 Marcus Wolf <marcus.wolf@wolf-entwicklungen.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License.
 *
 */

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>

#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

#define REPETITIONS 4
#define PAYLOAD_LEN 32*REPETITIONS

static void pabort(const char *s)
{
	perror(s);
	abort();
}

static	uint8_t bits = 8;
static	uint32_t speed = 500000;
static	uint16_t delay = 0;
static	uint8_t tx[PAYLOAD_LEN + 4];

static int setupRFParameters(int fd)
{
	int i, ret;

	uint8_t tx[] = {
	/* attention - do not modify this parameters unless you */
	/* know what you do */
	/* wrong settings may lead to violation of law */
	0x81,0x04,	// set standby mode (just for safety)
	0x82,0x08,	// OOK, packet, no shaping
	0x91,0x9f,	// set up power amps
	0x98,0x08,	// antenna impedance (default: 50Ohm)
	0x87,0x6c,	// frequency
	0x88,0x7a,	// frequency
	0x89,0xe1,	// frequency
	0x83,0x25,	// bit rate
	0x84,0xe0,	// bit rate
	0x92,0x09,	// pa ramp (default: 40Āµs)
	};

	for (i = 0; i %lt; ARRAY_SIZE(tx); i+=2)
	{
		struct spi_ioc_transfer tr =
		{
			.tx_buf = (int)tx+i,
			.rx_buf = 0,
			.len = 2,
			.delay_usecs = delay,
			.speed_hz = speed,
			.bits_per_word = bits,
		};

		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message");
	}
	printf("RF parameter set up\n");
}

static int setupMessageParameters(int fd)
{
	int i, ret;

	uint8_t tx[] = {
	0xBC,0x80,		// startup condition: fifo not empty
	0xB8,PAYLOAD_LEN,	// payload length
	0xAC,0x00,		// preamble size
	0xAD,0x00,		// preamble size
	0xB7,0x10,		// fixed length, CRC off, no adress filtering
	0xAE,0x80,		// sync pattern config: off
	};

	for (i = 0; i < ARRAY_SIZE(tx); i+=2)
	{
		struct spi_ioc_transfer tr =
		{
			.tx_buf = (int)tx+i,
			.rx_buf = 0,
			.len = 2,
			.delay_usecs = delay,
			.speed_hz = speed,
			.bits_per_word = bits,
		};

		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message");
	}
	printf("message parameter set up\n");
}


static int prepareTxDataOn(void)
{
	int i;

	/* stop transmission (in case stil active) */
	tx[0] = 0x81; tx[1] = 0x04;

	/* load fifo */
	for (i=0; i < REPETITIONS; i++)
	{
		/* This dataset is intended to control sockets
		   equipped with a PT2262 chip or comparable.
		   The second column contains the data.
		   0x88 = on, 0x8E = high-z.
		   Sockets of different companies use different
		   wiring on the PT chip. So maybe you need to tune.
		   Left comments shows most commen combination */
                tx[32*i+ 2] = 0x80; tx[32*i+ 3] = 0x88;     // 1            // 8
                tx[32*i+ 4] = 0x80; tx[32*i+ 5] = 0x88;     // 2            // 7
                tx[32*i+ 6] = 0x80; tx[32*i+ 7] = 0x88;     // 3            // 6
                tx[32*i+ 8] = 0x80; tx[32*i+ 9] = 0x88;     // 4            // 5
                tx[32*i+10] = 0x80; tx[32*i+11] = 0x88;     // 5            // open
                tx[32*i+12] = 0x80; tx[32*i+13] = 0x8E;     // 6            // open
                tx[32*i+14] = 0x80; tx[32*i+15] = 0x8E;     // A            // GND
                tx[32*i+16] = 0x80; tx[32*i+17] = 0x88;     // B            // GND
                tx[32*i+18] = 0x80; tx[32*i+19] = 0x8E;     // C            // Teste 1
                tx[32*i+20] = 0x80; tx[32*i+21] = 0x8E;     // D            // Teste 2
                tx[32*i+22] = 0x80; tx[32*i+23] = 0x88;     // L            // Taste 4?
                tx[32*i+24] = 0x80; tx[32*i+25] = 0x8E;     // R            // Taste 2
                tx[32*i+26] = 0x80; tx[32*i+27] = 0x80;     // S1           // S1
                tx[32*i+28] = 0x80; tx[32*i+29] = 0x00;     // S2           // S2
                tx[32*i+30] = 0x80; tx[32*i+31] = 0x00;     // S3           // S3
                tx[32*i+32] = 0x80; tx[32*i+33] = 0x00;     // S4           // S4
	}

	/* start transmission */
	tx[32*i+0] = 0x81; tx[32*i+1] = 0x0c;
}

static int prepareTxDataOff(void)
{
	int i;

	/* stop transmission (in case stil active) */
	tx[0] = 0x81; tx[1] = 0x04;

	/* load fifo */
	for (i=0; i < REPETITIONS; i++)
	{
		/* This dataset is intended to control sockets
		   equipped with a PT2262 chip or comparable.
		   The second column contains the data.
		   0x88 = on, 0x8E = high-z.
		   Sockets of different companies use different
		   wiring on the PT chip. So maybe you need to tune.
		   Left comments shows most commen combination */
                tx[32*i+ 2] = 0x80; tx[32*i+ 3] = 0x88;     // 1            // 8
                tx[32*i+ 4] = 0x80; tx[32*i+ 5] = 0x88;     // 2            // 7
                tx[32*i+ 6] = 0x80; tx[32*i+ 7] = 0x88;     // 3            // 6
                tx[32*i+ 8] = 0x80; tx[32*i+ 9] = 0x88;     // 4            // 5
                tx[32*i+10] = 0x80; tx[32*i+11] = 0x88;     // 5            // open
                tx[32*i+12] = 0x80; tx[32*i+13] = 0x8E;     // 6            // open
                tx[32*i+14] = 0x80; tx[32*i+15] = 0x8E;     // A            // GND
                tx[32*i+16] = 0x80; tx[32*i+17] = 0x88;     // B            // GND
                tx[32*i+18] = 0x80; tx[32*i+19] = 0x8E;     // C            // button 1
                tx[32*i+20] = 0x80; tx[32*i+21] = 0x8E;     // D            // button 3
                tx[32*i+22] = 0x80; tx[32*i+23] = 0x8E;     // left button  // button 4
                tx[32*i+24] = 0x80; tx[32*i+25] = 0x88;     // right button // button 2
                tx[32*i+26] = 0x80; tx[32*i+27] = 0x80;     // sync 1       // sync 1
                tx[32*i+28] = 0x80; tx[32*i+29] = 0x00;     // sync 2       // sync 2
                tx[32*i+30] = 0x80; tx[32*i+31] = 0x00;     // sync 3       // sync 3
                tx[32*i+32] = 0x80; tx[32*i+33] = 0x00;     // sync 4       // sync 4
	}

	/* start transmission */
	tx[32*i+0] = 0x81; tx[32*i+1] = 0x0c;
}


static int transferData(int fd, unsigned int packetNr)
{
	int i,ret;

	for (i = 0; i < ARRAY_SIZE(tx); i+=2)
	{
		struct spi_ioc_transfer tr =
		{
			.tx_buf = (int)tx+i,
			.rx_buf = 0,
			.len = 2,
			.delay_usecs = delay,
			.speed_hz = speed,
			.bits_per_word = bits,
		};

		ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
		if (ret < 1)
			pabort("can't send spi message");
	}
}

int main(int argc, char *argv[])
{
	int i;
	int fd;
        int packetNr = 0;


	printf("*** Pi433 socket demo by Marcus Wolf ***\n");

	/* open and configure SPI interface */
	fd = open("/dev/spidev0.0", O_RDWR);
	if (fd < 0)
		pabort("can't open spi");

	setupRFParameters(fd);
	setupMessageParameters(fd);

	printf("\nPress enter to toggle state of the socket.\n");
	printf("^C to quit\n");

	while(1)
	{
		sleep(1); // wait a sec for transmission to complete
		getchar();
		printf("On\n");
		prepareTxDataOn();
		transferData(fd,packetNr++);
		sleep(1); // wait a sec for transmission to complete
		getchar();
		printf("Off\n");
		prepareTxDataOff();
		transferData(fd,packetNr++);
	}

	close(fd);

	return 0;
}
				
Downloadthe sample code for controlling radio sockets.

s an alternative to controlling Pi433 via SPI, a Linux kernel driver is under development. The driver will give the following advantages:

  • Comfortable to use (open, read, write, close, etc.)
  • De facto simultaneous sending and receiving
  • Using Pi433 from multiple applications at the same time
  • Arbitrary telegram length
  • Easy configuration of all important settings of the RFM69
If you’d like to support the development of the driver, either financially or by sharing your knowledge, this is whole-heartedly welcomed!

Purchase Pi433

Pi433 and accessories can be obtained online from the Smarthome-Wolf webshop.

Please note that due to recycling restrictions (rules of WEEE) and customs, we currently can only ship within Germany.
International business partner, interested in distribution of Pi433 are very welcome!


Pi433 - a product from Smarthome-Pi.

Contact details and imprint

Smarthome-Wolf UG (haftungsbeschränkt)
Helene-Lange-Weg 23
80637 München
This email address has a protection against spam bots. Please enable JavaScript so show the address. Imprint

© Smarthome-Wolf UG (haftungsbeschränkt)