Dual_CAN.ino error?

README.md

@@ -1,15 +1,41 @@
-MCP2515 Library for Arduino
+MCP_CAN Library for Arduino
 ==============
-MCP2515 library v1.1
-This library is compatible with any shield or CAN interface that uses the MCP2515 CAN protocol controller.
-Baudrates 5k, 10k, 20k, 50k, 100k, 125k, 250k, 500k, & 1000k are confirmed to work using a Peak-System PCAN-USB dongle as a reference.
+MCP_CAN library v1.5
+This library is compatible with any shield or board that uses the MCP2515 or MCP25625 CAN protocol controller.
+
+This version supports setting the ID filter mode of the protocol controller, the BAUD rate with clock speed with the begin() function.  Baudrates 5k, 10k, 20k, 50k, 100k, 125k, 250k, 500k, & 1000k using 16MHz clock on the MCP2515 are confirmed to work using a Peak-System PCAN-USB dongle as a reference.  Baudrates for 8MHz and 20MHz crystals are yet to be confirmed but were calculated appropriately.
+
+**The readMsgBuf() functions bring in the message ID. The getCanId() function is obsolete and no longer exists, don't use it.**
+
+The readMsgBuf(*ID, *DLC, *DATA) function will return the ID type (extended or standard) and it will bring back the remote request status bit.  
+If the ID AND 0x80000000 EQUALS 0x80000000, the ID is of the Extended type, otherwise it is standard.  
+If the ID AND 0x40000000 EQUALS 0x40000000, the message is a remote request.  
+
+The readMsgBuf(*ID, *EXT, *DLC, *DATA) function will return the ID unaltered and doesn't inform us of a remote request.  
+If EXT is true, the ID is extended.  
+
+The sendMsgBuf(ID, DLC, DATA) function can send extended or standard IDs.  
+To mark an ID as extended, OR the ID with 0x80000000.    
+To send a remote request, OR the ID with 0x40000000.  
+
+The sendMsgBuf(ID, EXT, DLC, DATA) has not changed other than fixing return values.  
+
+Using the setMode() function the sketch can now put the protocol controller into sleep, loop-back, or listen-only modes as well as normal operation.  Right now the code defaults to loop-back mode after the begin() function runs.  I have found this to increase the stability of filtering when the controller is initialized while connected to an active bus.
+
+User can enable and disable (default) One-Shot transmission mode from the sketch using enOneShotTX() or disOneShotTX() respectively.
+
+To wake up from CAN bus activity while in sleep mode enable the wake up interrupt with setSleepWakeup(1). Passing 0 will disable the wakeup interrupt (default).
 
 Installation
 ==============
-Copy this into your "[...]/MySketches/libraries/" folder and restart the Arduino editor.
+Copy this into the "[.../MySketches/]libraries/" folder and restart the Arduino editor.
+
+NOTE: If an older version of the library exists (e.g. CAN_BUS_Shield) be sure to remove it from the libraries folder or replace the files with those in this library to avoid conflicts.
 
-NOTE: If you have an older version of the library (CAN_BUS_Shield) be sure to remove
- it from the libraries folder or replace the files with those in this library to avoid conflicts.
+
+Help and Support
+==============
+This is primarily for non-bug related issues: Please start a *new thread* in an appropriate area at Seeedstudio forums or Arduino.cc forums and then send me (coryjfowler) a link through the PM system, my user name is the same as it is here.  I will receive an email about the PM.  Keep in mind, I do this in my spare time.
 
 
 *Happy Coding!*

examples/CAN_loopback/CAN_loopback.ino

@@ -0,0 +1,88 @@
+/* CAN Loopback Example
+ * This example sends a message once a second and receives that message
+ *   no CAN bus is required.  This example will test the functionality 
+ *   of the protocol controller, and connections to it.
+ *   
+ *   Written By: Cory J. Fowler - October 5th 2016
+ */
+
+#include <mcp_can.h>
+#include <SPI.h>
+
+// CAN TX Variables
+unsigned long prevTX = 0;                                        // Variable to store last execution time
+const unsigned int invlTX = 1000;                                // One second interval constant
+byte data[] = {0xAA, 0x55, 0x01, 0x10, 0xFF, 0x12, 0x34, 0x56};  // Generic CAN data to send
+
+// CAN RX Variables
+long unsigned int rxId;
+unsigned char len;
+unsigned char rxBuf[8];
+
+// Serial Output String Buffer
+char msgString[128];
+
+// CAN0 INT and CS
+#define CAN0_INT 2                              // Set INT to pin 2
+MCP_CAN CAN0(10);                               // Set CS to pin 10
+
+
+void setup()
+{
+  Serial.begin(115200);  // CAN is running at 500,000BPS; 115,200BPS is SLOW, not FAST, thus 9600 is crippling.
+
+  // Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
+  if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK)
+    Serial.println("MCP2515 Initialized Successfully!");
+  else
+    Serial.println("Error Initializing MCP2515...");
+
+  // Since we do not set NORMAL mode, we are in loopback mode by default.
+  //CAN0.setMode(MCP_NORMAL);
+
+  pinMode(CAN0_INT, INPUT);                           // Configuring pin for /INT input
+
+  Serial.println("MCP2515 Library Loopback Example...");
+}
+
+void loop()
+{
+  if(!digitalRead(CAN0_INT))                          // If CAN0_INT pin is low, read receive buffer
+  {
+    CAN0.readMsgBuf(&rxId, &len, rxBuf);              // Read data: len = data length, buf = data byte(s)
+
+    if((rxId & 0x80000000) == 0x80000000)             // Determine if ID is standard (11 bits) or extended (29 bits)
+      sprintf(msgString, "Extended ID: 0x%.8lX  DLC: %1d  Data:", (rxId & 0x1FFFFFFF), len);
+    else
+      sprintf(msgString, "Standard ID: 0x%.3lX       DLC: %1d  Data:", rxId, len);
+
+    Serial.print(msgString);
+
+    if((rxId & 0x40000000) == 0x40000000){            // Determine if message is a remote request frame.
+      sprintf(msgString, " REMOTE REQUEST FRAME");
+      Serial.print(msgString);
+    } else {
+      for(byte i = 0; i<len; i++){
+        sprintf(msgString, " 0x%.2X", rxBuf[i]);
+        Serial.print(msgString);
+      }
+    }
+
+    Serial.println();
+  }
+
+  if(millis() - prevTX >= invlTX){                    // Send this at a one second interval. 
+    prevTX = millis();
+    byte sndStat = CAN0.sendMsgBuf(0x100, 8, data);
+
+    if(sndStat == CAN_OK)
+      Serial.println("Message Sent Successfully!");
+    else
+      Serial.println("Error Sending Message...");
+
+  }
+}
+
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

examples/CAN_receive/CAN_receive.ino

@@ -0,0 +1,62 @@
+// CAN Receive Example
+//
+
+#include <mcp_can.h>
+#include <SPI.h>
+
+long unsigned int rxId;
+unsigned char len = 0;
+unsigned char rxBuf[8];
+char msgString[128];                        // Array to store serial string
+
+#define CAN0_INT 2                              // Set INT to pin 2
+MCP_CAN CAN0(10);                               // Set CS to pin 10
+
+
+void setup()
+{
+  Serial.begin(115200);
+
+  // Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
+  if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK)
+    Serial.println("MCP2515 Initialized Successfully!");
+  else
+    Serial.println("Error Initializing MCP2515...");
+
+  CAN0.setMode(MCP_NORMAL);                     // Set operation mode to normal so the MCP2515 sends acks to received data.
+
+  pinMode(CAN0_INT, INPUT);                            // Configuring pin for /INT input
+
+  Serial.println("MCP2515 Library Receive Example...");
+}
+
+void loop()
+{
+  if(!digitalRead(CAN0_INT))                         // If CAN0_INT pin is low, read receive buffer
+  {
+    CAN0.readMsgBuf(&rxId, &len, rxBuf);      // Read data: len = data length, buf = data byte(s)
+
+    if((rxId & 0x80000000) == 0x80000000)     // Determine if ID is standard (11 bits) or extended (29 bits)
+      sprintf(msgString, "Extended ID: 0x%.8lX  DLC: %1d  Data:", (rxId & 0x1FFFFFFF), len);
+    else
+      sprintf(msgString, "Standard ID: 0x%.3lX       DLC: %1d  Data:", rxId, len);
+
+    Serial.print(msgString);
+
+    if((rxId & 0x40000000) == 0x40000000){    // Determine if message is a remote request frame.
+      sprintf(msgString, " REMOTE REQUEST FRAME");
+      Serial.print(msgString);
+    } else {
+      for(byte i = 0; i<len; i++){
+        sprintf(msgString, " 0x%.2X", rxBuf[i]);
+        Serial.print(msgString);
+      }
+    }
+
+    Serial.println();
+  }
+}
+
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

examples/CAN_send/CAN_send.ino

@@ -0,0 +1,36 @@
+// CAN Send Example
+//
+
+#include <mcp_can.h>
+#include <SPI.h>
+
+MCP_CAN CAN0(10);     // Set CS to pin 10
+
+void setup()
+{
+  Serial.begin(115200);
+
+  // Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
+  if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK) Serial.println("MCP2515 Initialized Successfully!");
+  else Serial.println("Error Initializing MCP2515...");
+
+  CAN0.setMode(MCP_NORMAL);   // Change to normal mode to allow messages to be transmitted
+}
+
+byte data[8] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
+
+void loop()
+{
+  // send data:  ID = 0x100, Standard CAN Frame, Data length = 8 bytes, 'data' = array of data bytes to send
+  byte sndStat = CAN0.sendMsgBuf(0x100, 0, 8, data);
+  if(sndStat == CAN_OK){
+    Serial.println("Message Sent Successfully!");
+  } else {
+    Serial.println("Error Sending Message...");
+  }
+  delay(100);   // send data per 100ms
+}
+
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/

examples/CAN_sleep/CAN_sleep.ino

@@ -0,0 +1,107 @@
+// CAN Sleep Example
+// By Zak Kemble, based on the CAN receive example
+
+// If you only have 2 devices on the CAN bus (the device running this sketch and some other device sending messages), then you may find that duplicate messages are received when waking up.
+// This is because when the MCP2515 wakes up it enters LISTENONLY mode where it does not send ACKs to messages, so the transmitter will retransmit the same message a few times.
+
+#include <mcp_can.h>
+#include <SPI.h>
+#include <avr/sleep.h>
+
+#define CAN0_INT 2 // Set INT to pin 2
+MCP_CAN CAN0(10); // Set CS to pin 10
+
+void setup()
+{
+	Serial.begin(115200);
+
+	// Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
+	if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK)
+		Serial.println(F("MCP2515 Initialized Successfully!"));
+	else
+		Serial.println(F("Error Initializing MCP2515..."));
+
+	CAN0.setMode(MCP_NORMAL); // Set operation mode to normal so the MCP2515 sends acks to received data.
+	CAN0.setSleepWakeup(1); // Enable wake up interrupt when in sleep mode
+
+	pinMode(CAN0_INT, INPUT); // Configuring pin for /INT input
+
+	// Enable interrupts for the CAN0_INT pin (should be pin 2 or 3 for Uno and other ATmega328P based boards)
+	attachInterrupt(digitalPinToInterrupt(CAN0_INT), ISR_CAN, FALLING);
+
+	set_sleep_mode(SLEEP_MODE_PWR_DOWN);
+
+	Serial.println(F("MCP2515 Library Sleep Example..."));
+}
+
+void loop()
+{
+	if(!digitalRead(CAN0_INT)) // If CAN0_INT pin is low, read receive buffer
+	{
+		unsigned long rxId;
+		byte len;
+		byte rxBuf[8];
+
+		if(CAN0.readMsgBuf(&rxId, &len, rxBuf) == CAN_OK) // Read data: len = data length, buf = data byte(s)
+		{
+			char msgString[128]; // Array to store serial string
+			if(rxId & CAN_IS_EXTENDED) // Determine if ID is standard (11 bits) or extended (29 bits)
+				sprintf_P(msgString, PSTR("Extended ID: 0x%.8lX  DLC: %1d  Data:"), (rxId & CAN_EXTENDED_ID), len);
+			else
+				sprintf_P(msgString, PSTR("Standard ID: 0x%.3lX       DLC: %1d  Data:"), rxId, len);
+
+			Serial.print(msgString);
+
+			if(rxId & CAN_IS_REMOTE_REQUEST) // Determine if message is a remote request frame.
+				Serial.print(F(" REMOTE REQUEST FRAME"));
+			else
+			{
+				for(byte i=0;i<len;i++)
+				{
+					sprintf_P(msgString, PSTR(" 0x%.2X"), rxBuf[i]);
+					Serial.print(msgString);
+				}
+			}
+
+			Serial.println();
+		}
+		else
+			Serial.println(F("Interrupt is asserted, but there were no messages to process..."));
+	}
+
+	Serial.println(F("SLEEPING..."));
+
+	// Put MCP2515 into sleep mode
+	// This can sometimes take up to around 100ms depending on what the chip is currently doing
+	CAN0.setMode(MCP_SLEEP);
+
+	Serial.println(F("SLEEP"));
+
+	// Clear serial buffers before sleeping
+	Serial.flush();
+
+	// Put the microcontroller to sleep
+	cli(); // Disable interrupts
+	if(digitalRead(CAN0_INT)) // Make sure we haven't missed an interrupt between the digitalRead() above and now. If an interrupt happens between now and sei()/sleep_cpu() then sleep_cpu() will immediately wake up again
+	{
+		sleep_enable();
+		sleep_bod_disable();
+		sei();
+		sleep_cpu();
+		sleep_disable();
+	}
+	sei();
+
+	Serial.println(F("WAKE"));
+
+	CAN0.setMode(MCP_NORMAL); // When the MCP2515 wakes up it will be in LISTENONLY mode, here we put it into NORMAL mode
+}
+
+static void ISR_CAN()
+{
+	// We don't do anything here, this is just for waking up the microcontroller
+}
+
+/*********************************************************************************************************
+  END FILE
+*********************************************************************************************************/