@rleh: added rx & tx queue options to lbuild + mcp2515 driver; removed unused project xml things; cleaned up unused headers; changed mcp2515 driver class attributes to not have _ underscore postfix

Author: kikass13

examples/nucleo_f439zi/can_m2515/main.cpp

@@ -13,7 +13,6 @@
 
 #include <modm/board.hpp>
 #include <modm/platform/spi/spi_master_1.hpp>
-#include <modm/platform/spi/spi_master_2.hpp>
 #include <modm/processing/protothread.hpp>
 #include <modm/driver/can/mcp2515.hpp>
 

examples/nucleo_f439zi/can_m2515/project.xml

@@ -1,18 +1,15 @@
 <library>
   <extends>modm:nucleo-f439zi</extends>
   <options>
-    <option name="modm:build:build.path">../../../build/stm32f4_discovery/mcp2515</option>
+    <option name="modm:build:build.path">../../../build/nucleo-f439zi/mcp2515</option>
+    <option name="modm:driver:mcp2515:buffer.tx">32</option>
+    <option name="modm:driver:mcp2515:buffer.rx">32</option>
   </options>
   <modules>
-    <module>modm:platform:gpio</module>
-    <module>modm:platform:spi.bitbang</module>
     <module>modm:platform:spi:1</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

@@ -21,13 +21,13 @@
 #include <modm/architecture/interface/delay.hpp>
 #include <modm/architecture/interface/can.hpp>
 #include <modm/architecture/interface/spi_device.hpp>
-#include <modm/architecture/driver/atomic/queue.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"
+#include "mcp2515_options.hpp"
 
 /**
  * \name	Restructure filter and mask bits for the MCP2515
@@ -125,7 +125,7 @@ namespace modm
 					protected modm::NestedResumable<4>
 	{
 	public:
-		Mcp2515() : messageBuffer_{}, delayR_{}, delayS_{} {
+		Mcp2515() : messageBuffer{}, delayS{} {
 			this->attachConfigurationHandler([]() {
 				SPI::setDataMode(SPI::DataMode::Mode3);
 				SPI::setDataOrder(SPI::DataOrder::MsbFirst);
@@ -240,30 +240,29 @@ namespace modm
 		readIdentifier(uint32_t& identifier);
 
 	private:
-		inline static modm::atomic::Queue<modm::can::Message, 32> txQueue;
-		inline static modm::atomic::Queue<modm::can::Message, 32> rxQueue;
+		inline static modm::mcp2515::options::TX_QUEUE txQueue;
+		inline static modm::mcp2515::options::RX_QUEUE rxQueue;
 
 		static SPI spi;
 		static CS chipSelect;
 		static INT interruptPin;
 
-		modm::can::Message messageBuffer_;
-		modm::ShortTimeout delayR_;
-		modm::ShortTimeout delayS_;
-		uint8_t statusBuffer_ = 0;
-		uint8_t statusBufferR_ = 0;
-		uint8_t statusBufferS_ = 0;
-		uint8_t statusBufferReady_ = 0;
-		uint8_t addressBufferR_ = 0;
-		uint8_t addressBufferS_ = 0;
-		uint8_t i_, j_ = 0;
-		uint8_t a_ = 0;
-		uint8_t b_ = 0;
-		uint8_t data_ = 0;
-		bool readTemp_ = false;
-		bool tempS_ = false;
-		bool temp_ = false;
-		bool receiveSuccess_ = false;
+		modm::can::Message messageBuffer;
+		modm::ShortTimeout delayS;
+		uint8_t statusBuffer = 0;
+		uint8_t statusBufferR = 0;
+		uint8_t statusBufferS = 0;
+		uint8_t statusBufferReady = 0;
+		uint8_t addressBufferR = 0;
+		uint8_t addressBufferS = 0;
+		uint8_t i, j = 0;
+		uint8_t a = 0;
+		uint8_t b = 0;
+		uint8_t data = 0;
+		bool readTemp = false;
+		bool tempS = false;
+		bool temp = false;
+		bool receiveSuccess = false;
 	};
 }
 

src/modm/driver/can/mcp2515.lb

@@ -25,6 +25,19 @@ def prepare(module, options):
                 "is selected according to the clock speed.",
             default="16MHz"))
 
+    module.add_option(
+        NumericOption(
+            name="buffer.tx",
+            description="",
+            minimum=1, maximum=2 ** 16 - 2,
+            default=32))
+    module.add_option(
+        NumericOption(
+            name="buffer.rx",
+            description="",
+            minimum=1, maximum=2 ** 16 - 2,
+            default=32))
+
     module.depends(
         ":architecture:accessor",
         ":architecture:assert",
@@ -44,3 +57,5 @@ def build(env):
     env.copy("mcp2515_bit_timings.hpp")
     env.copy("mcp2515_definitions.hpp")
     env.template("mcp2515.cpp.in")
+    env.template("mcp2515_options.hpp.in")
+

src/modm/driver/can/mcp2515_impl.hpp

@@ -17,7 +17,7 @@
 	#error	"Don't include this file directly, use 'mcp2515.hpp' instead!"
 #endif
 #include "mcp2515_bit_timings.hpp"
-#include "mcp2515_definitions.hpp"
+#include "mcp2515_options.hpp"
 #include <modm/architecture/interface/assert.hpp>
 
 // Set the log level
@@ -234,46 +234,46 @@ modm::Mcp2515<SPI, CS, INT>::mcp2515ReadMessage()
 	RF_BEGIN();
 
 	// read status flag of the device
-	statusBufferR_ = RF_CALL(readStatus(RX_STATUS));
+	statusBufferR = RF_CALL(readStatus(RX_STATUS));
 
-	readTemp_ = true;
-	if (statusBufferR_ & FLAG_RXB0_FULL) {
-		addressBufferR_ = READ_RX;			// message in buffer 0
+	readTemp = true;
+	if (statusBufferR & FLAG_RXB0_FULL) {
+		addressBufferR = READ_RX;			// message in buffer 0
 	}
-	else if (statusBufferR_ & FLAG_RXB1_FULL) {
-		addressBufferR_ = READ_RX | 0x04;	// message in buffer 1 (RXB1SIDH)
+	else if (statusBufferR & FLAG_RXB1_FULL) {
+		addressBufferR = READ_RX | 0x04;	// message in buffer 1 (RXB1SIDH)
 	}
 	else {
-		readTemp_ = false;						// Error: no message available
+		readTemp = false;						// Error: no message available
 	}
 
-	if(readTemp_)
+	if(readTemp)
 	{
 		RF_WAIT_UNTIL(this->acquireMaster());
 		chipSelect.reset();
-		RF_CALL(spi.transfer(addressBufferR_));
+		RF_CALL(spi.transfer(addressBufferR));
 
-		messageBuffer_.flags.extended = RF_CALL(readIdentifier(messageBuffer_.identifier));
-		if (statusBufferR_ & FLAG_RTR) {
-			messageBuffer_.flags.rtr = true;
+		messageBuffer.flags.extended = RF_CALL(readIdentifier(messageBuffer.identifier));
+		if (statusBufferR & FLAG_RTR) {
+			messageBuffer.flags.rtr = true;
 		}
 		else {
-			messageBuffer_.flags.rtr = false;
+			messageBuffer.flags.rtr = false;
 		}
 
-		messageBuffer_.length = RF_CALL(spi.transfer(0xff)) & 0x0f;
+		messageBuffer.length = RF_CALL(spi.transfer(0xff)) & 0x0f;
 
-		for (j_ = 0; j_ < messageBuffer_.length; ++j_) {
-			data_ = RF_CALL(spi.transfer(0xff));
-			messageBuffer_.data[j_] = data_;
+		for (j = 0; j < messageBuffer.length; ++j) {
+			data = RF_CALL(spi.transfer(0xff));
+			messageBuffer.data[j] = data;
 		}
 		RF_WAIT_UNTIL(this->releaseMaster());
 		chipSelect.set();
 	}
 	// RX0IF or RX1IF respectivly were already cleared automatically by rising CS.
 	// See section 12.4 in datasheet.
 
-	RF_END_RETURN(readTemp_);
+	RF_END_RETURN(readTemp);
 }
 
 template <typename SPI, typename CS, typename INT>
@@ -288,7 +288,7 @@ modm::Mcp2515<SPI, CS, INT>::update(){
 	if(!interruptPin.read()){
 		if(RF_CALL(mcp2515ReadMessage()))
 		{
-			if(not modm_assert_continue_ignore(rxQueue.push(messageBuffer_), "mcp2515.can.tx",
+			if(not modm_assert_continue_ignore(rxQueue.push(messageBuffer), "mcp2515.can.tx",
 			"CAN transmit software buffer overflowed!", 1)){}
 		}
 	}
@@ -313,16 +313,16 @@ modm::Mcp2515<SPI, CS, INT>::mcp2515IsReadyToSend()
 
 	RF_BEGIN();
 
-	tempS_ = true;
-	statusBufferReady_ = RF_CALL(readStatus(READ_STATUS));
-	if (( statusBufferReady_& (TXB2CNTRL_TXREQ | TXB1CNTRL_TXREQ | TXB0CNTRL_TXREQ)) ==
+	tempS = true;
+	statusBufferReady = RF_CALL(readStatus(READ_STATUS));
+	if (( statusBufferReady& (TXB2CNTRL_TXREQ | TXB1CNTRL_TXREQ | TXB0CNTRL_TXREQ)) ==
 			(TXB2CNTRL_TXREQ | TXB1CNTRL_TXREQ | TXB0CNTRL_TXREQ))
 	{
 		// all buffers currently in use
-		tempS_ = false;
+		tempS = false;
 	}
 
-	RF_END_RETURN(tempS_);
+	RF_END_RETURN(tempS);
 }
 template <typename SPI, typename CS, typename INT>
 bool
@@ -347,32 +347,32 @@ modm::Mcp2515<SPI, CS, INT>::mcp2515SendMessage(const can::Message& message)
 	using namespace modm::mcp2515;
 	RF_BEGIN();
 
-	statusBufferS_ = RF_CALL(readStatus(READ_STATUS));
+	statusBufferS = RF_CALL(readStatus(READ_STATUS));
 
-	addressBufferS_ = static_cast<uint8_t>(false);
+	addressBufferS = static_cast<uint8_t>(false);
 
 	// /// send if ready, else return that nothing was sent
-	if(mcp2515IsReadyToSend(statusBufferS_))
+	if(mcp2515IsReadyToSend(statusBufferS))
 	{
-		if ((statusBufferS_ & TXB0CNTRL_TXREQ) == 0)
+		if ((statusBufferS & TXB0CNTRL_TXREQ) == 0)
 		{
-			addressBufferS_ = 0x00;  // TXB0SIDH
-		} else if ((statusBufferS_ & TXB1CNTRL_TXREQ) == 0)
+			addressBufferS = 0x00;  // TXB0SIDH
+		} else if ((statusBufferS & TXB1CNTRL_TXREQ) == 0)
 		{
-			addressBufferS_ = 0x02;  // TXB1SIDH
-		} else if ((statusBufferS_ & TXB2CNTRL_TXREQ) == 0)
+			addressBufferS = 0x02;  // TXB1SIDH
+		} else if ((statusBufferS & TXB2CNTRL_TXREQ) == 0)
 		{
-			addressBufferS_ = 0x04;  // TXB2SIDH
+			addressBufferS = 0x04;  // TXB2SIDH
 		} else
 		{
 			// all buffer are in use => could not send the message
 		}
 
-		if (addressBufferS_ == 0x00 || addressBufferS_ == 0x02 || addressBufferS_ == 0x04)
+		if (addressBufferS == 0x00 || addressBufferS == 0x02 || addressBufferS == 0x04)
 		{
 			RF_WAIT_UNTIL(this->acquireMaster());
 			chipSelect.reset();
-			RF_CALL(spi.transfer(WRITE_TX | addressBufferS_));
+			RF_CALL(spi.transfer(WRITE_TX | addressBufferS));
 			RF_CALL(writeIdentifier(message.identifier, message.flags.extended));
 
 			// if the message is a rtr-frame, is has a length but no attached data
@@ -383,24 +383,24 @@ modm::Mcp2515<SPI, CS, INT>::mcp2515SendMessage(const can::Message& message)
 			{
 				RF_CALL(spi.transfer(message.length));
 
-				for (i_ = 0; i_ < message.length; ++i_) {
-					RF_CALL(spi.transfer(message.data[i_]));
+				for (i = 0; i < message.length; ++i) {
+					RF_CALL(spi.transfer(message.data[i]));
 				}
 			}
-			delayS_.restart(1ms);
+			delayS.restart(1ms);
 			chipSelect.set();
-			RF_WAIT_UNTIL(delayS_.isExpired());
+			RF_WAIT_UNTIL(delayS.isExpired());
 
 			// send message via RTS command
 			chipSelect.reset();
-			addressBufferS_ = (addressBufferS_ == 0) ? 1 : addressBufferS_;  // 0 2 4 => 1 2 4
-			RF_CALL(spi.transfer(RTS | addressBufferS_));
+			addressBufferS = (addressBufferS == 0) ? 1 : addressBufferS;  // 0 2 4 => 1 2 4
+			RF_CALL(spi.transfer(RTS | addressBufferS));
 			RF_WAIT_UNTIL(this->releaseMaster());
 			chipSelect.set();
 		}
 	}
 
-	RF_END_RETURN(static_cast<bool>(addressBufferS_));
+	RF_END_RETURN(static_cast<bool>(addressBufferS));
 }
 
 // ----------------------------------------------------------------------------
@@ -449,11 +449,11 @@ modm::Mcp2515<SPI, CS, INT>::readStatus(uint8_t type)
 	RF_WAIT_UNTIL(this->acquireMaster());
 	chipSelect.reset();
 	RF_CALL(spi.transfer(type));
-	statusBuffer_ = RF_CALL(spi.transfer(0xff));
+	statusBuffer = RF_CALL(spi.transfer(0xff));
 	RF_WAIT_UNTIL(this->releaseMaster());
 	chipSelect.set();
 
-	RF_END_RETURN(statusBuffer_);
+	RF_END_RETURN(statusBuffer);
 }
 
 // ----------------------------------------------------------------------------
@@ -474,10 +474,10 @@ modm::Mcp2515<SPI, CS, INT>::writeIdentifier(const uint32_t& identifier,
 		RF_CALL(spi.transfer(*((uint16_t *)ptr + 1) >> 5));
 
 		// calculate the next values
-		a_ = (*((uint8_t *)ptr + 2) << 3) & 0xe0;
-		a_ |= MCP2515_IDE;
-		a_ |= (*((uint8_t *)ptr + 2)) & 0x03;
-		RF_CALL(spi.transfer(a_));
+		a = (*((uint8_t *)ptr + 2) << 3) & 0xe0;
+		a |= MCP2515_IDE;
+		a |= (*((uint8_t *)ptr + 2)) & 0x03;
+		RF_CALL(spi.transfer(a));
 		RF_CALL(spi.transfer(*((uint8_t *)ptr + 1)));
 		RF_CALL(spi.transfer(*((uint8_t *)ptr)));
 	} else
@@ -502,36 +502,36 @@ modm::Mcp2515<SPI, CS, INT>::readIdentifier(uint32_t &identifier)
 	RF_BEGIN();
 
 	RF_WAIT_UNTIL(this->acquireMaster());
-	a_ = RF_CALL(spi.transfer(0xff));
-	b_ = RF_CALL(spi.transfer(0xff));
+	a = RF_CALL(spi.transfer(0xff));
+	b = RF_CALL(spi.transfer(0xff));
 
-	temp_ = false;
+	temp = false;
 
-	if (b_ & MCP2515_IDE)
+	if (b & MCP2515_IDE)
 	{
-		*((uint16_t *)ptr + 1) = (uint16_t)a_ << 5;
+		*((uint16_t *)ptr + 1) = (uint16_t)a << 5;
 		*((uint8_t *)ptr + 1) = RF_CALL(spi.transfer(0xff));
 
-		*((uint8_t *)ptr + 2) |= (b_ >> 3) & 0x1C;
-		*((uint8_t *)ptr + 2) |= b_ & 0x03;
+		*((uint8_t *)ptr + 2) |= (b >> 3) & 0x1C;
+		*((uint8_t *)ptr + 2) |= b & 0x03;
 
 		*((uint8_t *)ptr) = RF_CALL(spi.transfer(0xff));
 
-		temp_ = true;
+		temp = true;
 	} else
 	{
 		RF_CALL(spi.transfer(0xff));
 
 		*((uint8_t *)ptr + 3) = 0;
 		*((uint8_t *)ptr + 2) = 0;
 
-		*((uint16_t *)ptr) = (uint16_t)a_ << 3;
+		*((uint16_t *)ptr) = (uint16_t)a << 3;
 
 		RF_CALL(spi.transfer(0xff));
 
-		*((uint8_t *)ptr) |= b_ >> 5;
+		*((uint8_t *)ptr) |= b >> 5;
 	}
 	RF_WAIT_UNTIL(this->releaseMaster());
 
-	RF_END_RETURN(temp_);
+	RF_END_RETURN(temp);
 }