Use mysensors built-in nrf24 library for RPi

2016-09-14 23:26:12 -03:00
parent 4175a5f423
commit fab2112f9b
22 changed files with 4051 additions and 544 deletions
@@ -0,0 +1,106 @@
+/*
+ * The MySensors Arduino library handles the wireless radio link and protocol
+ * between your home built sensors/actuators and HA controller of choice.
+ * The sensors forms a self healing radio network with optional repeaters. Each
+ * repeater and gateway builds a routing tables in EEPROM which keeps track of the
+ * network topology allowing messages to be routed to nodes.
+ *
+ * Created by Marcelo Aquino <marceloaqno@gmail.org>
+ * Copyright (C) 2016 Marcelo Aquino
+ * Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
+ *
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * Based on TMRh20 RF24 library, Copyright (c) 2015 Charles-Henri Hallard <tmrh20@gmail.com>
+ */
+
+#include "SPI.h"
+#include <pthread.h>
+#include <stdlib.h>
+#include "log.h"
+
+static pthread_mutex_t spiMutex = PTHREAD_MUTEX_INITIALIZER;
+
+// Declare a single default instance
+SPIClass SPI = SPIClass();
+
+uint8_t SPIClass::initialized = 0;
+
+SPIClass::SPIClass() {
+	if (!bcm2835_init()) {
+		mys_log(LOG_ERR, "Failed to initialized bcm2835.\n");
+		exit(1);
+	}
+}
+
+SPIClass::~SPIClass() {}
+
+uint8_t SPIClass::isInitialized() {
+	return initialized;
+}
+
+void SPIClass::begin() {
+	if (!initialized) {
+		if (!bcm2835_spi_begin()) {
+			mys_log(LOG_ERR, "You need to be root to use SPI.\n");
+			exit(1);
+		}
+	}
+
+	initialized++; // reference count
+}
+
+void SPIClass::end() {
+	if (initialized) {
+		initialized--;
+	}
+
+	if (!initialized) {
+		// End the SPI
+		bcm2835_spi_end();
+	}
+}
+
+void SPIClass::setBitOrder(uint8_t bit_order) {
+	bcm2835_spi_setBitOrder(bit_order);
+}
+
+void SPIClass::setDataMode(uint8_t data_mode) {
+	bcm2835_spi_setDataMode(data_mode);
+}
+
+void SPIClass::setClockDivider(uint16_t divider) {
+	bcm2835_spi_setClockDivider(divider);
+}
+
+void SPIClass::chipSelect(int csn_pin) {
+	if (csn_pin == RPI_GPIO_P1_26) csn_pin = BCM2835_SPI_CS1;
+	else if (csn_pin == RPI_GPIO_P1_24) csn_pin = BCM2835_SPI_CS0;
+	else csn_pin = BCM2835_SPI_CS0;
+	bcm2835_spi_chipSelect(csn_pin);
+	delayMicroseconds(5);
+}
+
+void SPIClass::beginTransaction(SPISettings settings) {
+	pthread_mutex_lock(&spiMutex);
+	setBitOrder(settings.border);
+	setDataMode(settings.dmode);
+	setClockDivider(settings.cdiv);
+}
+
+void SPIClass::endTransaction() {
+	pthread_mutex_unlock(&spiMutex);
+}
+
+void SPIClass::usingInterrupt(uint8_t interruptNumber) {
+	(void)interruptNumber;
+}
+
+void SPIClass::notUsingInterrupt(uint8_t interruptNumber) {
+	(void)interruptNumber;
+}
@@ -0,0 +1,231 @@
+/*
+ * The MySensors Arduino library handles the wireless radio link and protocol
+ * between your home built sensors/actuators and HA controller of choice.
+ * The sensors forms a self healing radio network with optional repeaters. Each
+ * repeater and gateway builds a routing tables in EEPROM which keeps track of the
+ * network topology allowing messages to be routed to nodes.
+ *
+ * Created by Marcelo Aquino <marceloaqno@gmail.org>
+ * Copyright (C) 2016 Marcelo Aquino
+ * Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
+ *
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * Based on TMRh20 RF24 library, Copyright (c) 2015 Charles-Henri Hallard <tmrh20@gmail.com>
+ */
+#ifndef _SPI_H_
+#define _SPI_H_
+
+#include <stdio.h>
+#include "bcm2835.h"
+
+#define SPI_HAS_TRANSACTION
+
+// SPI Clock divider
+#define SPI_CLOCK_DIV2 2
+#define SPI_CLOCK_DIV4 4
+#define SPI_CLOCK_DIV8 8
+#define SPI_CLOCK_DIV16 16
+#define SPI_CLOCK_DIV32 32
+#define SPI_CLOCK_DIV64 64
+#define SPI_CLOCK_DIV128 128
+
+// SPI Data mode
+#define SPI_MODE0 BCM2835_SPI_MODE0
+#define SPI_MODE1 BCM2835_SPI_MODE1
+#define SPI_MODE2 BCM2835_SPI_MODE2
+#define SPI_MODE3 BCM2835_SPI_MODE3
+
+/**
+ * SPISettings class
+ */
+class SPISettings {
+
+public:
+	/**
+	 * @brief SPISettings constructor.
+	 *
+	 * Default clock speed is 8Mhz.
+	 */
+	SPISettings() {
+		init(BCM2835_SPI_CLOCK_DIVIDER_32, BCM2835_SPI_BIT_ORDER_MSBFIRST, BCM2835_SPI_MODE0);
+	}
+	/**
+	 * @brief SPISettings constructor.
+	 *
+	 * @param clock SPI clock speed in Hz.
+	 * @param bitOrder SPI bit order.
+	 * @param dataMode SPI data mode.
+	 */
+	SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) {
+		uint16_t divider;
+
+		switch (clock) {
+			case 500000:
+				divider = BCM2835_SPI_CLOCK_DIVIDER_512;
+				break;
+			case 1000000:
+				divider = BCM2835_SPI_CLOCK_DIVIDER_256;
+				break;
+			case 2000000:
+				divider = BCM2835_SPI_CLOCK_DIVIDER_128;
+				break;
+			case 4000000:
+				divider = BCM2835_SPI_CLOCK_DIVIDER_64;
+				break;
+			case 8000000:
+				divider = BCM2835_SPI_CLOCK_DIVIDER_32;
+				break;
+			case 16000000:
+				divider = BCM2835_SPI_CLOCK_DIVIDER_16;
+				break;
+			default:
+				// 8Mhz
+				divider = BCM2835_SPI_CLOCK_DIVIDER_32;
+		}
+
+		init(divider, bitOrder, dataMode);
+	}
+
+	uint16_t cdiv; //!< @brief SPI clock divider.
+	uint8_t border; //!< @brief SPI bit order.
+	uint8_t dmode; //!< @brief SPI data mode.
+
+private:
+	/**
+	 * @brief Initialized class members.
+	 *
+	 * @param divider SPI clock divider.
+	 * @param bitOrder SPI bit order.
+	 * @param dataMode SPI data mode.
+	 */
+	void init(uint16_t divider, uint8_t bitOrder, uint8_t dataMode) {
+		cdiv = divider;
+		border = bitOrder;
+		dmode = dataMode;
+	}
+
+	friend class SPIClass;
+};
+
+/**
+ * SPIClass class
+ */
+class SPIClass {
+
+private:
+	static uint8_t initialized; //!< @brief SPI initialized flag.
+
+public:
+	/**
+	 * @brief SPIClass constructor.
+	 */
+	SPIClass();
+	/**
+	 * @brief SPIClass destructor.
+	 */
+	virtual ~SPIClass();
+	/**
+	 * @brief Checks if SPI was initialized.
+	 *
+	 * @return 0 if wasn't initialized, else 1 or more.
+	 */
+	static uint8_t isInitialized();
+	/**
+	 * @brief Send and receive a byte.
+	 *
+	 * @param data to send.
+	 * @return byte received.
+	 */
+	inline static uint8_t transfer(uint8_t data);
+	/**
+	 * @brief Send and receive a number of bytes.
+	 *
+	 * @param tbuf Sending buffer.
+	 * @param rbuf Receive buffer.
+	 * @param len Buffer length.
+	 */
+	inline static void transfernb(char* tbuf, char* rbuf, uint32_t len);
+	/**
+	 * @brief Send and receive a number of bytes.
+	 *
+	 * @param buf Buffer to read from and write to.
+	 * @param len Buffer length.
+	 */
+	inline static void transfern(char* buf, uint32_t len);  
+	/**
+	 * @brief Start SPI operations.
+	 */
+	static void begin();
+	/**
+	 * @brief End SPI operations.
+	 */
+	static void end();
+	/**
+	 * @brief Sets the SPI bit order.
+	 *
+	 * @param bit_order The desired bit order.
+	 */
+	static void setBitOrder(uint8_t bit_order);
+	/**
+	 * @brief Sets the SPI data mode.
+	 *
+	 * @param data_mode The desired data mode.
+	 */
+	static void setDataMode(uint8_t data_mode);
+	/**
+	 * @brief Sets the SPI clock divider and therefore the SPI clock speed.
+	 *
+	 * @param divider The desired SPI clock divider.
+	 */
+	static void setClockDivider(uint16_t divider);
+	/**
+	 * @brief Sets the chip select pin.
+	 *
+	 * @param csn_pin Specifies the CS pin.
+	 */
+	static void chipSelect(int csn_pin);
+	/**
+	 * @brief Start SPI transaction.
+	 *
+	 * @param settings for SPI.
+	 */
+	static void beginTransaction(SPISettings settings);
+	/**
+	 * @brief End SPI transaction.
+	 */
+	static void endTransaction();
+	/**
+	 * @brief Not implemented.
+	 *
+	 * @param interruptNumber ignored parameter.
+	 */
+	static void usingInterrupt(uint8_t interruptNumber);
+	/**
+	 * @brief Not implemented.
+	 *
+	 * @param interruptNumber ignored parameter.
+	 */
+	static void notUsingInterrupt(uint8_t interruptNumber);
+};
+
+uint8_t SPIClass::transfer(uint8_t data) {
+	return bcm2835_spi_transfer(data);
+}
+
+void SPIClass::transfernb(char* tbuf, char* rbuf, uint32_t len) {
+	bcm2835_spi_transfernb( tbuf, rbuf, len);
+}
+
+void SPIClass::transfern(char* buf, uint32_t len) {
+	transfernb(buf, buf, len);
+}
+
+extern SPIClass SPI;
+
+#endif
@@ -0,0 +1,48 @@
+/*
+ * piHiPri:
+ *	Simple way to get your program running at high priority
+ *	with realtime schedulling.
+ *
+ *	Copyright (c) 2012 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as
+ *    published by the Free Software Foundation, either version 3 of the
+ *    License, or (at your option) any later version.
+ *
+ *    wiringPi is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with wiringPi.
+ *    If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <sched.h>
+#include <string.h>
+
+/*
+ * piHiPri:
+ *	Attempt to set a high priority schedulling for the running program
+ *********************************************************************************
+ */
+
+int piHiPri (const int pri)
+{
+  struct sched_param sched ;
+
+  memset (&sched, 0, sizeof(sched)) ;
+
+  if (pri > sched_get_priority_max (SCHED_RR))
+    sched.sched_priority = sched_get_priority_max (SCHED_RR) ;
+  else
+    sched.sched_priority = pri ;
+
+  return sched_setscheduler (0, SCHED_RR, &sched) ;
+}
@@ -0,0 +1,330 @@
+/*
+ * The MySensors Arduino library handles the wireless radio link and protocol
+ * between your home built sensors/actuators and HA controller of choice.
+ * The sensors forms a self healing radio network with optional repeaters. Each
+ * repeater and gateway builds a routing tables in EEPROM which keeps track of the
+ * network topology allowing messages to be routed to nodes.
+ *
+ * Created by Marcelo Aquino <marceloaqno@gmail.org>
+ * Copyright (C) 2016 Marcelo Aquino
+ * Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
+ *
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * Based on wiringPi Copyright (c) 2012 Gordon Henderson.
+ */
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <poll.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stropts.h>
+#include <errno.h>
+#include "rpi_util.h"
+#include "SPI.h"
+#include "log.h"
+
+extern "C" {
+	int piHiPri(const int pri);
+}
+
+struct ThreadArgs {
+	void (*func)();
+	int gpioPin;
+};
+
+static pthread_mutex_t intMutex = PTHREAD_MUTEX_INITIALIZER;
+
+static pthread_t *threadIds[64] = {NULL};
+
+// sysFds:
+//	Map a file descriptor from the /sys/class/gpio/gpioX/value
+static int sysFds[64] =
+{
+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+};
+
+#ifdef __RPI_BPLUS
+static uint8_t physToGpio[64] =
+{
+	255,		// 0
+	255, 255,	// 1, 2
+	  2, 255,
+	  3, 255,
+	  4,  14,
+	255,  15,
+	 17,  18,
+	 27, 255,
+	 22,  23,
+	255,  24,
+	 10, 255,
+	  9,  25,
+	 11,   8,
+	255,   7,	// 25, 26
+// B+
+	  0,   1,
+	  5, 255,
+	  6,  12,
+	 13, 255,
+	 19,  16,
+	 26,  20,
+	255,  21,
+// the P5 connector on the Rev 2 boards:
+	255, 255,
+	255, 255,
+	255, 255,
+	255, 255,
+	255, 255,
+	 28,  29,
+	 30,  31,
+	255, 255,
+	255, 255,
+	255, 255,
+	255, 255,
+};
+#else
+static uint8_t physToGpio[64] =
+{
+	255,		// 0
+	255, 255,	// 1, 2
+	  0, 255,
+	  1, 255,
+	  4,  14,
+	255,  15,
+	 17,  18,
+	 21, 255,
+	 22,  23,
+	255,  24,
+	 10, 255,
+	  9,  25,
+	 11,   8,
+	255,   7,	// 25, 26
+														   255, 255, 255, 255, 255,	// ... 31
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,	// ... 47
+	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,	// ... 63
+};
+#endif
+
+void *interruptHandler(void *args) {
+	int fd, ret;
+	struct pollfd polls;
+	char c;
+	struct ThreadArgs *arguments = (struct ThreadArgs *)args;
+	int gpioPin = arguments->gpioPin;
+	void (*func)() = arguments->func;
+	delete arguments;
+
+	(void)piHiPri(55);	// Only effective if we run as root
+
+	if ((fd = sysFds[gpioPin]) == -1) {
+		mys_log(LOG_ERR, "Failed to attach interrupt for pin %d\n", gpioPin);
+		return NULL;
+	}
+
+	// Setup poll structure
+	polls.fd     = fd;
+	polls.events = POLLPRI;
+
+	while (1) {
+		// Wait for it ...
+		ret = poll(&polls, 1, -1);
+		if (ret < 0) {
+			mys_log(LOG_ERR, "Error waiting for interrupt: %s\n", strerror(errno));
+			break;
+		}
+		// Do a dummy read to clear the interrupt
+		//	A one character read appars to be enough.
+		//	Followed by a seek to reset it.
+		(void)read (fd, &c, 1) ;
+  		lseek (fd, 0, SEEK_SET) ;
+		// Call user function.
+		func();
+	}
+
+	close(fd);
+
+	return NULL;
+}
+
+void rpi_util::pinMode(uint8_t physPin, uint8_t mode) {
+	uint8_t gpioPin = (physPin > 63)? 255 : physToGpio[physPin];
+	if (gpioPin == 255) {
+		mys_log(LOG_ERR, "pinMode: invalid pin: %d\n", physPin);
+		return;
+	}
+	// Check if SPI is in use and target pin is related to SPI
+	if (SPIClass::isInitialized() && gpioPin >= RPI_GPIO_P1_26 && gpioPin <= RPI_GPIO_P1_23) {
+		return;
+	} else {
+		bcm2835_gpio_fsel(gpioPin, mode);
+	}
+}
+
+void rpi_util::digitalWrite(uint8_t physPin, uint8_t value) {
+	uint8_t gpioPin = (physPin > 63)? 255 : physToGpio[physPin];
+	if (gpioPin == 255) {
+		mys_log(LOG_ERR, "digitalWrite: invalid pin: %d\n", physPin);
+		return;
+	}
+	// Check if SPI is in use and target pin is related to SPI
+	if (SPIClass::isInitialized() && gpioPin >= RPI_GPIO_P1_26 && gpioPin <= RPI_GPIO_P1_23) {
+		if (value == LOW && (gpioPin == RPI_GPIO_P1_24 || gpioPin == RPI_GPIO_P1_26)) {
+			SPI.chipSelect(gpioPin);
+		}
+	} else {
+		bcm2835_gpio_write(gpioPin, value);
+		// Delay to allow any change in state to be reflected in the LEVn, register bit.
+		delayMicroseconds(1);
+	}
+}
+
+uint8_t rpi_util::digitalRead(uint8_t physPin) {
+	uint8_t gpioPin = (physPin > 63)? 255 : physToGpio[physPin];
+	if (gpioPin == 255) {
+		mys_log(LOG_ERR, "digitalRead: invalid pin: %d\n", physPin);
+		return 0;
+	}
+	// Check if SPI is in use and target pin is related to SPI
+	if (SPIClass::isInitialized() && gpioPin >= RPI_GPIO_P1_26 && gpioPin <= RPI_GPIO_P1_23) {
+		return 0;
+	} else {
+		return bcm2835_gpio_lev(gpioPin);
+	}
+}
+
+void rpi_util::attachInterrupt(uint8_t physPin, void (*func)(), uint8_t mode) {
+	FILE *fd;
+	char fName[40];
+	char c;
+	int count, i;
+
+	uint8_t gpioPin = (physPin > 63)? 255 : physToGpio[physPin];
+	if (gpioPin == 255) {
+		mys_log(LOG_ERR, "attachInterrupt: invalid pin: %d\n", physPin);
+		return;
+	}
+
+	if (threadIds[gpioPin] == NULL) {
+		threadIds[gpioPin] = new pthread_t;
+	} else {
+		// Cancel the existing thread for that pin
+		pthread_cancel(*threadIds[gpioPin]);
+		// Wait a bit
+		delay(1L);
+	}
+
+	// Export pin for interrupt
+	if ((fd = fopen("/sys/class/gpio/export", "w")) == NULL) {
+		mys_log(LOG_ERR, "attachInterrupt: Unable to export pin %d for interrupt: %s\n", physPin, strerror(errno));
+		exit(1);
+	}
+	fprintf(fd, "%d\n", gpioPin); 
+	fclose(fd);
+
+	// Wait a bit the system to create /sys/class/gpio/gpio<GPIO number>
+	delay(1L);
+
+	snprintf(fName, sizeof(fName), "/sys/class/gpio/gpio%d/direction", gpioPin) ;
+	if ((fd = fopen (fName, "w")) == NULL) {
+		fprintf (stderr, "attachInterrupt: Unable to open GPIO direction interface for pin %d: %s\n", physPin, strerror(errno));
+		exit(1) ;
+	}
+	fprintf(fd, "in\n") ;
+	fclose(fd) ;
+
+	snprintf(fName, sizeof(fName), "/sys/class/gpio/gpio%d/edge", gpioPin) ;
+	if ((fd = fopen(fName, "w")) == NULL) {
+		fprintf (stderr, "attachInterrupt: Unable to open GPIO edge interface for pin %d: %s\n", physPin, strerror(errno));
+		exit(1) ;
+	}
+	switch (mode) {
+		case CHANGE: fprintf(fd, "both\n"); break;
+		case FALLING: fprintf(fd, "falling\n"); break;
+		case RISING: fprintf(fd, "rising\n"); break;
+		case NONE: fprintf(fd, "none\n"); break;
+		default:
+			mys_log(LOG_ERR, "attachInterrupt: Invalid mode\n");
+			fclose(fd);
+			return;
+	}
+	fclose(fd);
+
+	if (sysFds[gpioPin] == -1) {
+		snprintf(fName, sizeof(fName), "/sys/class/gpio/gpio%d/value", gpioPin);
+		if ((sysFds[gpioPin] = open(fName, O_RDWR)) < 0) {
+			fprintf (stderr, "Error reading pin %d: %s\n", physPin, strerror(errno));
+			exit(1);
+		}
+	}
+
+	// Clear any initial pending interrupt
+	ioctl(sysFds[gpioPin], FIONREAD, &count);
+	for (i = 0; i < count; ++i) {
+		if (read(sysFds[gpioPin], &c, 1) == -1) {
+			mys_log(LOG_ERR, "attachInterrupt: failed to read pin status: %s\n", strerror(errno));
+		}
+	}
+
+	struct ThreadArgs *threadArgs = new struct ThreadArgs;
+	threadArgs->func = func;
+	threadArgs->gpioPin = gpioPin;
+
+	// Create a thread passing the pin and function
+	pthread_create(threadIds[gpioPin], NULL, interruptHandler, (void *)threadArgs);
+}
+
+void rpi_util::detachInterrupt(uint8_t physPin) {
+	uint8_t gpioPin = (physPin > 63)? 255 : physToGpio[physPin];
+	if (gpioPin == 255) {
+		mys_log(LOG_ERR, "detachInterrupt: invalid pin: %d\n", physPin);
+		return;
+	}
+
+	// Cancel the thread
+	if (threadIds[gpioPin] != NULL) {
+		pthread_cancel(*threadIds[gpioPin]);
+		delete threadIds[gpioPin];
+		threadIds[gpioPin] = NULL;
+	}
+
+	// Close filehandle
+	if (sysFds[gpioPin] != -1) {
+		close(sysFds[gpioPin]);
+		sysFds[gpioPin] = -1;
+	}
+
+	FILE *fp = fopen("/sys/class/gpio/unexport", "w");
+	if (fp == NULL) {
+		mys_log(LOG_ERR, "Unable to unexport pin %d for interrupt\n", gpioPin);
+		exit(1);
+	}
+	fprintf(fp, "%d", gpioPin); 
+	fclose(fp);
+}
+
+uint8_t rpi_util::digitalPinToInterrupt(uint8_t physPin) {
+	// No need to convert the pin to gpio, we do it in attachInterrupt().
+	return physPin;
+}
+
+void rpi_util::interrupts() {
+	pthread_mutex_unlock(&intMutex);
+}
+
+void rpi_util::noInterrupts() {
+	pthread_mutex_lock(&intMutex);
+}
@@ -0,0 +1,71 @@
+/*
+ * The MySensors Arduino library handles the wireless radio link and protocol
+ * between your home built sensors/actuators and HA controller of choice.
+ * The sensors forms a self healing radio network with optional repeaters. Each
+ * repeater and gateway builds a routing tables in EEPROM which keeps track of the
+ * network topology allowing messages to be routed to nodes.
+ *
+ * Created by Marcelo Aquino <marceloaqno@gmail.org>
+ * Copyright (C) 2016 Marcelo Aquino
+ * Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
+ *
+ * Documentation: http://www.mysensors.org
+ * Support Forum: http://forum.mysensors.org
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * Based on wiringPi Copyright (c) 2012 Gordon Henderson.
+ */
+
+#ifndef pins_io_h
+#define pins_io_h
+
+#include <stdint.h>
+#include "bcm2835.h"
+
+namespace rpi_util {
+
+typedef enum {
+	LSBFIRST = BCM2835_SPI_BIT_ORDER_LSBFIRST,
+	MSBFIRST = BCM2835_SPI_BIT_ORDER_MSBFIRST
+} rpi_bitorder;
+
+typedef enum {
+	INPUT = BCM2835_GPIO_FSEL_INPT,
+	OUTPUT = BCM2835_GPIO_FSEL_OUTP
+} rpi_pinmode;
+
+typedef enum {
+	CHANGE = 1,
+	FALLING = 2,
+	RISING = 3,
+	NONE = 4
+} rpi_pinedge;
+
+typedef enum {
+	PIN_SPI_SS = RPI_GPIO_P1_24,
+	PIN_SPI_MOSI = RPI_GPIO_P1_19,
+	PIN_SPI_MISO = RPI_GPIO_P1_21,
+	PIN_SPI_SCK = RPI_GPIO_P1_23
+} rpi_spipins;
+
+const uint8_t SS   = PIN_SPI_SS;
+const uint8_t MOSI = PIN_SPI_MOSI;
+const uint8_t MISO = PIN_SPI_MISO;
+const uint8_t SCK  = PIN_SPI_SCK;
+
+/* Some useful arduino functions */
+void pinMode(uint8_t physPin, uint8_t mode);
+void digitalWrite(uint8_t physPin, uint8_t value);
+uint8_t digitalRead(uint8_t physPin);
+void attachInterrupt(uint8_t physPin,void (*func)(), uint8_t mode);
+void detachInterrupt(uint8_t physPin);
+uint8_t digitalPinToInterrupt(uint8_t physPin);
+void interrupts();
+void noInterrupts();
+
+}
+
+#endif