changed mcp2515 driver to use nonblocking spi

examples/stm32f4_discovery/can_m2515/main.cpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2013, Kevin Läufer
+ * Copyright (c) 2013-2017, Niklas Hauser
+ * Copyright (c) 2016, Raphael Lehmann
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#include <modm/board.hpp>
+#include <modm/driver/can/mcp2515.hpp>
+#include <modm/processing/protothread.hpp>
+
+// If you use a different SPI instance, you may have to also choose different
+// GPIOs to connect to.
+using Int = GpioOutputB11;
+using Cs = GpioOutputB12;
+using Sck = GpioOutputB13;
+using Mosi = GpioOutputB15;
+using Miso = GpioInputB14;
+using SpiMaster = SpiMaster2;
+// Note that you can also use a bit-banged SPI driver as a drop-in replacement
+// using SpiMaster = BitBangSpiMaster<Sck, Mosi, Miso>;
+
+// Default filters to receive any extended CAN frame
+FLASH_STORAGE(uint8_t canFilter[]) = {
+	MCP2515_FILTER_EXTENDED(0),  // Filter 0
+	MCP2515_FILTER_EXTENDED(0),  // Filter 1
+
+	MCP2515_FILTER_EXTENDED(0),  // Filter 2
+	MCP2515_FILTER_EXTENDED(0),  // Filter 3
+	MCP2515_FILTER_EXTENDED(0),  // Filter 4
+	MCP2515_FILTER_EXTENDED(0),  // Filter 5
+
+	MCP2515_FILTER_EXTENDED(0),  // Mask 0
+	MCP2515_FILTER_EXTENDED(0),  // Mask 1
+};
+
+modm::Mcp2515<SpiMaster, Cs, Int> mcp2515;
+
+class MyTask : modm::pt::Protothread
+{
+public:
+	MyTask() : message_{0x123456}
+	{
+		mcp2515.initialize<8_MHz, 125_kbps>();
+		mcp2515.setFilter(modm::accessor::asFlash(canFilter));
+	}
+
+	bool
+	run()
+	{
+		PT_BEGIN();
+
+		// send a new message
+		message_.length = 2;
+		message_.data[0] = 0xab;
+		message_.data[1] = 0xcd;
+		mcp2515.sendMessage(message_);
+
+		while (true)
+		{
+			if (mcp2515.isMessageAvailable())
+			{
+				mcp2515.getMessage(message_);
+				MODM_LOG_INFO << "Received message: " << message_.identifier << modm::endl;
+			}
+			PT_CALL(mcp2515.update());
+		}
+		PT_END();
+	}
+
+private:
+	modm::can::Message message_;
+};
+
+MyTask task;
+
+int
+main()
+{
+	Board::initialize();
+
+	// Initialize SPI interface and the other pins
+	// needed by the MCP2515
+	SpiMaster::connect<Miso::Miso, Mosi::Mosi, Sck::Sck>();
+	/// we initialize a higher baud rate then n the avr example, dunnow hats the mcp2515 is capable
+	/// of
+	SpiMaster::initialize<Board::SystemClock, 20_MHz>();
+	Cs::setOutput();
+	Int::setInput(Gpio::InputType::PullUp);
+
+	// Configure MCP2515 and set the filters
+	mcp2515.initialize<8_MHz, 125_kbps>();
+
+	while (true) { task.run(); }
+}

examples/stm32f4_discovery/can_m2515/project.xml

@@ -0,0 +1,17 @@
+<library>
+  <extends>modm:disco-f407vg</extends>
+  <options>
+    <option name="modm:build:build.path">../../../build/stm32f4_discovery/mcp2515</option>
+  </options>
+  <modules>
+    <module>modm:platform:gpio</module>
+    <module>modm:platform:spi.bitbang</module>
+    <module>modm:platform:spi:2</module>
+    <module>modm:build:scons</module>
+
+    <module>modm:processing:protothread</module>
+    <module>modm:processing:timer</module>
+    <module>modm:driver:mcp2515</module>
+
+  </modules>
+</library>

src/modm/driver/can/mcp2515.hpp

@@ -20,6 +20,9 @@
 #include <modm/architecture/interface/accessor.hpp>
 #include <modm/architecture/interface/delay.hpp>
 #include <modm/architecture/interface/can.hpp>
+#include <modm/processing/protothread.hpp>
+#include <modm/processing/resumable.hpp>
+#include <modm/processing/timer.hpp>
 #include <modm/debug/logger.hpp>
 
 #include "mcp2515_definitions.hpp"
@@ -115,7 +118,7 @@ namespace modm
 	template < typename SPI,
 			   typename CS,
 			   typename INT >
-    class Mcp2515 : public ::modm::Can
+    class Mcp2515 : public ::modm::Can, modm::NestedResumable<4>
 	{
 	public:
 		template<frequency_t ExternalClock, bitrate_t bitrate=kbps(125), percent_t tolerance=pct(1) >
@@ -143,7 +146,7 @@ namespace modm
 		isMessageAvailable();
 
 		static bool
-		getMessage(can::Message& message);
+		getMessage(can::Message& message, uint8_t *filter_id=nullptr);
 
 		/*
 		 * The CAN controller has a free slot to send a new message.
@@ -158,9 +161,18 @@ namespace modm
 		 *
 		 * \return true if the message was send, false otherwise
 		 */
-		static bool
+		bool
 		sendMessage(const can::Message& message);
 
+		/*
+		 * Poll the transmit buffer (shoudl be called periodically) 
+		 *
+		 * \return true if a message was send this cycle, false otherwise
+		 */
+		modm::ResumableResult<bool>
+		update();
+
+
     public:
         // Extended Functionality
 
@@ -186,6 +198,21 @@ namespace modm
 			BIT_MODIFY = 0x05
 		};
 
+		static void
+		mcp2515interrupt();
+
+		static bool
+		mcp2515readMessage(can::Message& message);
+
+		bool
+		mcp2515isReadyToSend(uint8_t status);
+
+		modm::ResumableResult<bool>
+		mcp2515isReadyToSend();
+
+		modm::ResumableResult<bool>
+		mcp2515sendMessage(const can::Message& message, const uint8_t status = 0xff);
+
 		static void
 		writeRegister(uint8_t address, uint8_t data);
 
@@ -195,10 +222,13 @@ namespace modm
 		static void
 		bitModify(uint8_t address, uint8_t mask, uint8_t data);
 
-		static uint8_t
+		modm::ResumableResult<uint8_t>
 		readStatus(uint8_t type);
 
-		static inline void
+		static uint8_t
+		readStatusBlocking(uint8_t type);
+
+		inline modm::ResumableResult<void>
 		writeIdentifier(const uint32_t& identifier, bool isExtendedFrame);
 
 		static inline bool

src/modm/driver/can/mcp2515.lb

@@ -31,6 +31,10 @@ def prepare(module, options):
         ":architecture:can",
         ":architecture:clock",
         ":architecture:delay",
+        ":architecture:interrupt",
+        ":processing:protothread",
+        ":processing:timer",
+        ":platform:exti",
         ":debug")
     return True