Ein Funkmodul für den Raspberry Pi

Du möchtest mit deinem Raspberry Pi auf einfache Art und Weise ein paar Daten übertragen, deine Funksteckdose ansteuern oder die Daten einer Funkwetterstation empfangen
Du möchtest aber weder deinen Lötkolben auspacken, noch eine fliegende Verdrahtung?

Dann bist du hier genau richtig!

Mit Pi433 ist endlich ein Erweiterungsmodul verfügbar, dass Deinen Raspberry Pi im Handumdrehen um einen 433MHz Sender und Empfänger erweitert. Denn Pi433 kann einfach auf die GPIO-Steckleiste Deines Raspberrys aufgesteckt werden!
Dabei ist Pi433 so klein, dass es mühelos in handelsüblichen Gehäusen verschwindet.

Pi433 ist mit einer „on Board“ Antenne ausgestattet, die für viele Anwendungen ausreicht. Wird eine größere Reichweite benötigt, so kann diese mit Hilfe einer Zusatzantenne realisiert werden, für die auf Pi433 eine U.FL-Antennebuchse zur Verfügung steht.

Mit Pi433 wird es möglich, Raspberry Pis untereinander kommunizieren zu lassen. Es kann auch mit Geräten anderer Hersteller, die im 433MHz Band aktiv sind, kommuniziert werden. So können z.B. Befehle an Funksteckdosen oder Ähnliches gesendet oder Informationen von Funkthermometern oder ähnlich empfangen werden.

Sitemap

Highlights von Pi433
Technische Informationen
Anschluß von Pi433
Ansteuerung von Pi433
Pi433 erwerben
Kontakt und Impressum

Highlights von Pi433

  • passt auf alle Derivate der Raspberry Pi Serie (bei Pi Zero muss die Steckleiste nachgerüstet werden)
  • passt auf viele weitere Einplatinencomputer mit Raspberry Pi kompatibler GPIO-Steckleiste (Banana Pi, Orange Pi, ...)
  • belegt nur 10 Pins der GPIO-Steckleiste - die anderen Pins bleiben frei verfügbar
  • unterstützt das Senden und Empfangen
  • Unterstützt verschiedene Modulationen (FSK, MSK, OOK)
  • Sendefrequenz im Bereich des 433MHz ISM-Bandes (433,05 bis 434,79 MHz) frei einstellbar
  • verfügt über ein FIFO - Daten müssen nicht in Echtzeit per "Pinwackeln" geschickt werden
  • verfügt über verschiedene Komfortfunktionen (Preambelegeneration und -erkennung, Adressfilter, AES, CRC)
  • verfügt über eine PCB-Antenne, die für kleine Reichweiten genutzt werden kann
  • verfügt über eine U-FL-Buchse, an der für größere Reichweiten eine externen Antenne angeschlossen werden kann
  • ein Kernel-Treiber für Linux ist im Stagingbereich des Kenel-Source-Tree verfügbar.
  • CE konform

Technische Informationen

Pi433 ist mit einem Sende- und Empfangsmodul vom Typ RFM69 der Firma Hope-RF ausgestattet. Das Datenblatt des Moduls ist im Internet frei verfügbar - z. B. unter RFM69CW. Es beinhaltet eine ausführliche Beschreibung der Funktionsweise und der Register des Moduls. Die technischen Daten des Moduls gelten nahezu uneingeschränkt auch für Pi433:
  • +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 verbindet das RFM69 Modul über die SPI-Schnittstelle mit dem Raspberry Pi. Zusätzlich zur SPI sind die drei digital I/O Pins DIO0, DIO1 und DIO2 des Moduls verbunden. Dabei gilt folgende Zuordnung:

ModulRaspberry Pi
DIO0GPIO24
DIO1GPIO25
DIO2GPIO7

Anschluss von Pi433

Das Modul wird auf die GPIO-Steckleiste des Raspberry Pi gesteckt.

Beim Raspberry-Pi der zweiten und dritten Generation sowie beim Modell B+ muß das Modul mittig auf die GPIO-Steckleiste gesteckt werden. Auf der linken, der Netzwerkbuchse zugewandten Seite bleiben sieben Doppelpins frei, auf der rechten bleiben acht Doppelpins frei.

Beim Raspberry-Pi der ersten Generation wird das Modul bündig auf die der Videobuchse zugewandten Seite gesteckt.

Ansteuerung von Pi433

Pi433 wird über die SPI Schnittstelle angesteuert.
Die Register und deren Verwendung ist im Datenblatt des RFM69CW Modul übersichtlich und ausführlich dokumentiert.

Die beiden unten stehenden Quellcodes verdeutlichen die Ansteuerung auf der Basis eines einfachen Senders, der auf Tastendruck 16 Bytes versendet. Das Empfängerprogramm konfiguriert das RFM69 passend dazu und überwacht kontinuierlich, ob ein Telegram gesendet wurde. Dabei werden einige der Sicherungsmechanismen des RFM69 (Preambel, Syncwort und CRC) verwendet, um die Übertragung abzusichern.

Den Quellcode des Senders 
/*
 * 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;
}
Den Quellcode des Empfängers 
/*
 * 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;
}

Den Quellcode des Sender herunterladen.
Den Quellcode des Empfängers herunterladen.

Das folgende Beispiel dient der Ansteuerung einfacher Funksteckdosen mit PT2262 Chipsatz (oder kompatibel - z. B. HX2262, SC5272). Für den Test des Beispielprogramms wurde eine Funksteckdose des Funksteckdosenset PFS-3 aus dem Hause Pollin verwendet.

Den Quellcode der Funksteckdosenansteuerung 
/*
 * 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;
}
Den Quellcode der Funksteckdosenansteuerung herunterladen.

Als Alternative zum SPI-Zugriff kann auf einen Linux-Kerneltreiber zurückgegriffen werden, der bereits heute im Staging-Bereich des offiziellen Kernel veröffentlicht ist. Der Treiber bietet unter Anderem folgende Vorteile:

  • Komfortables Interface (open, read, write, close statt Registerzugriffe)
  • Quasi gleichzeitiges Senden und Empfangen
  • Paralleler Zugriff mehrerer Applikationen auf den Sendeteil des Treibers
  • Beliebige Telegrammlänge durch automatisches Nachladen/Leeren des FiFos während der Übertragung
  • Einfache Konfigurationsmöglichkeit aller wesentlichen Features des RFM69

Pi433 erwerben

Aufgrund hoher Kosten für Recycling-Zertifikate (WEEE-Richtlinie der EU) hat sich Smarthome-Wolf entschieden, den Direktvertrieb von Pi433 einzustellen.

Wir sind nach wie vor auf der Suche nach Handelspartnern (z. B Online-Stores für Raspberry-Pi Zubehör), die am Vertrieb von Pi433 interessiert sind!


Pi433 - ein Produkt der Marke Smarthome-Pi

Kontakt und Impressum

Smarthome-Wolf UG (haftungsbeschränkt)
Helene-Lange-Weg 23
80637 München
Die E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige bitte JavaScript einschalten. Impressum

© Smarthome-Wolf UG (haftungsbeschränkt)