Linux: Add support for SPIDEV (#734)

RPi and Linux refactor.

Add GPIO Sysfs for GPIO operations.

Update configure script.

Fix some cppcheck warnings.

Add serial emulation that prints to stdout.

Fix some file headers.

drivers/BCM/Wire.cpp

@@ -0,0 +1,213 @@
+/*
+  TwoWire.h - TWI/I2C library for Arduino & Wiring
+  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+
+  This library 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 2.1 of the License, or (at your option) any later version.
+
+  This library 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 this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
+  Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
+  Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
+  Modified October 2016 by Marcelo Aquino <marceloaqno@gmail.org> for Raspberry Pi
+*/
+
+#include "Wire.h"
+#include <stdlib.h>
+#include <pthread.h>
+#include "bcm2835.h"
+#include "log.h"
+
+static pthread_mutex_t i2cMutex = PTHREAD_MUTEX_INITIALIZER;
+
+uint8_t TwoWire::rxBuffer[BUFFER_LENGTH];
+uint8_t TwoWire::rxBufferIndex = 0;
+uint8_t TwoWire::rxBufferLength = 0;
+
+uint8_t TwoWire::txAddress = 0;
+uint8_t TwoWire::txBuffer[BUFFER_LENGTH];
+uint8_t TwoWire::txBufferIndex = 0;
+uint8_t TwoWire::txBufferLength = 0;
+
+uint8_t TwoWire::transmitting = 0;
+
+void TwoWire::begin()
+{
+	if (!bcm2835_i2c_begin()) {
+		logError("You need root privilege to use I2C.\n");
+		exit(1);
+	}
+}
+
+void TwoWire::begin(uint8_t address)
+{
+	begin();
+	bcm2835_i2c_setSlaveAddress(address);
+}
+
+void TwoWire::begin(int address)
+{
+	begin(static_cast<uint8_t>(address));
+}
+
+void TwoWire::end()
+{
+	bcm2835_i2c_end();
+}
+
+void TwoWire::setClock(uint32_t clock)
+{
+	bcm2835_i2c_set_baudrate(clock);
+}
+
+void TwoWire::beginTransmission(uint8_t address)
+{
+	pthread_mutex_lock(&i2cMutex);
+	// indicate that we are transmitting
+	transmitting = 1;
+	// set address of targeted slave
+	txAddress = address;
+	// reset tx buffer iterator vars
+	txBufferIndex = 0;
+	txBufferLength = 0;
+}
+
+void TwoWire::beginTransmission(int address)
+{
+	beginTransmission(static_cast<uint8_t>(address));
+}
+
+uint8_t TwoWire::endTransmission(void)
+{
+	// transmit buffer
+	bcm2835_i2c_setSlaveAddress(txAddress);
+	uint8_t ret = bcm2835_i2c_write(reinterpret_cast<const char *>(txBuffer), txBufferLength);
+
+	// reset tx buffer iterator vars
+	txBufferIndex = 0;
+	txBufferLength = 0;
+	// indicate that we are done transmitting
+	transmitting = 0;
+
+	pthread_mutex_unlock(&i2cMutex);
+
+	if (ret == BCM2835_I2C_REASON_OK) {
+		return 0;	// success
+	} else if (ret == BCM2835_I2C_REASON_ERROR_NACK) {
+		return 3;	// error: data send, nack received
+	}
+	return 4;	// other error
+}
+
+size_t TwoWire::requestFrom(uint8_t address, size_t quantity)
+{
+	// clamp to buffer length
+	if (quantity > BUFFER_LENGTH) {
+		quantity = BUFFER_LENGTH;
+	}
+
+	rxBufferIndex = 0;
+	rxBufferLength = 0;
+
+	bcm2835_i2c_setSlaveAddress(address);
+	uint8_t ret = bcm2835_i2c_read(reinterpret_cast<char *>(rxBuffer), quantity);
+	if (ret == BCM2835_I2C_REASON_OK) {
+		rxBufferLength = quantity;
+	}
+
+	return rxBufferLength;
+}
+
+uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity)
+{
+	return requestFrom(address, static_cast<size_t>(quantity));
+}
+
+uint8_t TwoWire::requestFrom(int address, int quantity)
+{
+	return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity));
+}
+
+size_t TwoWire::write(uint8_t data)
+{
+	if (transmitting) {
+		// in master transmitter mode
+		// don't bother if buffer is full
+		if (txBufferLength >= BUFFER_LENGTH) {
+			setWriteError();
+			return 0;
+		}
+		// put byte in tx buffer
+		txBuffer[txBufferIndex] = data;
+		++txBufferIndex;
+		// update amount in buffer
+		txBufferLength = txBufferIndex;
+
+		return 1;
+	} else {
+		return write(&data, 1);
+	}
+}
+
+size_t TwoWire::write(const uint8_t *data, size_t quantity)
+{
+	if (transmitting) {
+		// in master transmitter mode
+		for (size_t i = 0; i < quantity; ++i) {
+			write(data[i]);
+		}
+	} else {
+		uint8_t rc = bcm2835_i2c_write(reinterpret_cast<const char *>(data), quantity);
+		if (rc != BCM2835_I2C_REASON_OK) {
+			return 0;
+		}
+	}
+
+	return quantity;
+}
+
+int TwoWire::available()
+{
+	return rxBufferLength - rxBufferIndex;
+}
+
+int TwoWire::read()
+{
+	int value = -1;
+
+	if (rxBufferIndex < rxBufferLength) {
+		value = rxBuffer[rxBufferIndex];
+		++rxBufferIndex;
+	}
+
+	return value;
+}
+
+int TwoWire::peek()
+{
+	if (rxBufferIndex < rxBufferLength) {
+		return rxBuffer[rxBufferIndex];
+	}
+
+	return -1;
+}
+
+void TwoWire::flush()
+{
+	rxBufferIndex = 0;
+	rxBufferLength = 0;
+	txBufferIndex = 0;
+	txBufferLength = 0;
+}
+
+TwoWire Wire = TwoWire();