Added GPIO interface and implementation for pin and MCP23017.

Author: dhebbeker

robot-control-src/DigitalPin.hpp

@@ -0,0 +1,77 @@
+#ifndef ROBOT_CONTROL_SRC_DIGITALPIN_HPP_
+#define ROBOT_CONTROL_SRC_DIGITALPIN_HPP_
+
+#include "GpioInterface.hpp"
+#include <Arduino.h>
+
+template<std::uint8_t PIN>
+class DigitalPin: public GpioInterface {
+public:
+	static constexpr std::uint8_t pin = PIN;
+
+	virtual int read() override
+	{
+		return readS();
+	}
+	virtual void setMode(const std::uint8_t mode) override
+	{
+		setModeS(mode);
+	}
+	virtual void write(const std::uint8_t value) override
+	{
+		writeS(value);
+	}
+	void setDutyCycle(const int dutyCycle) const
+	{
+		setDutyCycleS(dutyCycle);
+	}
+	static int readS()
+	{
+		return digitalRead(pin);
+	}
+	static void setModeS(const std::uint8_t mode)
+	{
+		pinMode(pin, mode);
+	}
+	static void writeS(const std::uint8_t value)
+	{
+		digitalWrite(pin, value);
+	}
+	static void setDutyCycleS(const int dutyCycle)
+	{
+		analogWrite(pin, dutyCycle);
+	}
+};
+
+template<std::uint8_t PIN>
+void analogWrite(const DigitalPin<PIN>& gpio, const int dutyCycle)
+{
+	analogWrite(gpio.pin, dutyCycle);
+}
+
+inline constexpr int digitalPinToInterruptWrapper(const int pinNumber)
+{
+	return digitalPinToInterrupt(pinNumber);
+}
+
+#undef digitalPinToInterrupt
+
+inline constexpr int digitalPinToInterrupt(const int pinNumber)
+{
+	return digitalPinToInterruptWrapper(pinNumber);
+}
+
+template<std::uint8_t PIN>
+int constexpr digitalPinToInterrupt(const DigitalPin<PIN>& gpio)
+{
+	return digitalPinToInterruptWrapper(gpio.pin);
+}
+
+template<std::uint8_t PIN>
+void attachInterrupt(const DigitalPin<PIN>& gpio, void (* const interruptServiceRoutine)(void), const int mode)
+{
+	attachInterrupt(digitalPinToInterrupt(gpio.pin), interruptServiceRoutine, mode);
+}
+
+
+#endif /* ROBOT_CONTROL_SRC_DIGITALPIN_HPP_ */

robot-control-src/GpioInterface.cpp

@@ -0,0 +1,16 @@
+#include "GpioInterface.hpp"
+
+void digitalWrite(GpioInterface& gpio, const std::uint8_t value)
+{
+	gpio.write(value);
+}
+
+int digitalRead(GpioInterface& gpio)
+{
+	return gpio.read();
+}
+
+void pinMode(GpioInterface& gpio, const std::uint8_t mode)
+{
+	gpio.setMode(mode);
+}

robot-control-src/GpioInterface.hpp

@@ -0,0 +1,19 @@
+#ifndef GPIOINTERFACE_HPP_
+#define GPIOINTERFACE_HPP_
+
+#include <cstdint>
+
+class GpioInterface {
+public:
+	virtual void write(const std::uint8_t value) = 0;
+	virtual int read() = 0;
+	virtual void setMode(const std::uint8_t mode) = 0;
+
+	virtual ~GpioInterface() {};
+};
+
+void digitalWrite(GpioInterface& gpio, const std::uint8_t value);
+int digitalRead(GpioInterface& gpio);
+void pinMode(GpioInterface& gpio, const std::uint8_t mode);
+
+#endif /* GPIOINTERFACE_HPP_ */

robot-control-src/MCP23017Pin.cpp

@@ -0,0 +1,24 @@
+#include "MCP23017Pin.hpp"
+#include <MCP23017.h>
+
+MCP23017Pin::MCP23017Pin(MCP23017 &ioExpander, std::uint8_t const pin) :ioExpander(ioExpander), pin(pin) {
+}
+
+MCP23017Pin::~MCP23017Pin() {
+}
+
+int MCP23017Pin::read() {
+	return ioExpander.digitalRead(pin);
+}
+
+void MCP23017Pin::setMode(std::uint8_t const mode) {
+	setMode(mode, false);
+}
+
+void MCP23017Pin::setMode(std::uint8_t const mode, bool const inverted) {
+	ioExpander.pinMode(pin, mode, inverted);
+}
+
+void MCP23017Pin::write(std::uint8_t const value) {
+	ioExpander.digitalWrite(pin, value);
+}

robot-control-src/MCP23017Pin.hpp

@@ -0,0 +1,21 @@
+#ifndef MCP23017PIN_HPP_
+#define MCP23017PIN_HPP_
+
+#include "GpioInterface.hpp"
+
+class MCP23017;
+
+class MCP23017Pin: public GpioInterface {
+public:
+	MCP23017Pin(MCP23017& ioExpander, const std::uint8_t pin);
+	virtual ~MCP23017Pin();
+	virtual int read() override;
+	virtual void setMode(const std::uint8_t mode) override;
+	void setMode(const std::uint8_t mode, const bool inverted);
+	virtual void write(const std::uint8_t value) override;
+private:
+	MCP23017& ioExpander;
+	const std::uint8_t pin;
+};
+
+#endif /* MCP23017PIN_HPP_ */