Optimize MCP2515Class::parsePacket()

1) Use the RX STATUS command instead of READ(CANINTF) to check availability of
   data to read. This reduces SPI usage by 1 byte out of 3, even to just check
   if data is available.

2) Use the READ command to read RXB(n) registers sequentially instead of
   requesting them one by one. This requires 7 bytes over SPI to read SIDH,
   SIDL, EID8, EID0, DLC. The previous implementation used 15 bytes to read the
   register for standard frames, and 24 bytes for extended frames.

3) Use the READ RX BUFFER command to read the packet data, instead of requesting
   bytes one by one. This requires sending (1 + N) bytes over SPI instead of
   (3 * N) for the payload, and doesn't require sending 3 bytes to modify RXnIF.

Total savings: (2 * N + 11) bytes over SPI for standard frame.
For N = 8, we now send 18 bytes over SPI vs 45. That's 60% reduction!

As a bonus, I was able to put all SPI operations in one SPI transaction.
I don't know if it makes much of a difference, but perhaps makes things safer?

Author: timurrrr

src/MCP2515.cpp

@@ -214,47 +214,86 @@ int MCP2515Class::parsePacket()
 {
   int n;
 
-  uint8_t intf = readRegister(REG_CANINTF);
+  SPI.beginTransaction(_spiSettings);
+  digitalWrite(_csPin, LOW);
+  SPI.transfer(0xb0);  // RX STATUS
+  uint8_t rxStatus = SPI.transfer(0x00);
+  digitalWrite(_csPin, HIGH);
 
-  if (intf & FLAG_RXnIF(0)) {
+  if (rxStatus & 0x40) {
     n = 0;
-  } else if (intf & FLAG_RXnIF(1)) {
+  } else if (rxStatus & 0x80) {
     n = 1;
   } else {
+    SPI.endTransaction();
     _rxId = -1;
     _rxExtended = false;
     _rxRtr = false;
+    _rxDlc = 0;
+    _rxIndex = 0;
     _rxLength = 0;
     return 0;
   }
 
-  _rxExtended = (readRegister(REG_RXBnSIDL(n)) & FLAG_IDE) ? true : false;
+  digitalWrite(_csPin, LOW);
+  SPI.transfer(0x03);  // READ
+  SPI.transfer(REG_RXBnSIDH(n));
+  uint8_t regSIDH = SPI.transfer(0x00);
+  uint8_t regSIDL = SPI.transfer(0x00);
+
+  // We could just skip the EID registers, but that would actually add more
+  // overhead just to send a new READ command.
+  uint8_t regEID8 = SPI.transfer(0x00);
+  uint8_t regEID0 = SPI.transfer(0x00);
+  uint8_t regDLC = SPI.transfer(0x00);
+  digitalWrite(_csPin, HIGH);
+
+  _rxExtended = (regSIDL & FLAG_IDE) ? true : false;
 
-  uint32_t idA = ((readRegister(REG_RXBnSIDH(n)) << 3) & 0x07f8) | ((readRegister(REG_RXBnSIDL(n)) >> 5) & 0x07);
+  uint32_t idA = (regSIDH << 3) | (regSIDL >> 5);
   if (_rxExtended) {
-    uint32_t idB = (((uint32_t)(readRegister(REG_RXBnSIDL(n)) & 0x03) << 16) & 0x30000) | ((readRegister(REG_RXBnEID8(n)) << 8) & 0xff00) | readRegister(REG_RXBnEID0(n));
+    uint32_t idB =
+        ((uint32_t)(regSIDL & 0x03) << 16)
+        | ((uint32_t)regEID8 << 8)
+        | regEID0;
 
     _rxId = (idA << 18) | idB;
-    _rxRtr = (readRegister(REG_RXBnDLC(n)) & FLAG_RTR) ? true : false;
+    _rxRtr = (regDLC & FLAG_RTR) ? true : false;
   } else {
     _rxId = idA;
-    _rxRtr = (readRegister(REG_RXBnSIDL(n)) & FLAG_SRR) ? true : false;
+    _rxRtr = (regSIDL & FLAG_SRR) ? true : false;
   }
-  _rxDlc = readRegister(REG_RXBnDLC(n)) & 0x0f;
+  _rxDlc = regDLC & 0x0f;
   _rxIndex = 0;
 
   if (_rxRtr) {
     _rxLength = 0;
+
+    // Need to manually clear the RX flag.
+    digitalWrite(_csPin, LOW);
+    SPI.transfer(0x05); // BIT MODIFY
+    SPI.transfer(REG_CANINTF);
+    SPI.transfer(FLAG_RXnIF(n));
+    SPI.transfer(0x0);
+    digitalWrite(_csPin, HIGH);
   } else {
     _rxLength = _rxDlc;
 
-    for (int i = 0; i < _rxLength; i++) {
-      _rxData[i] = readRegister(REG_RXBnD0(n) + i);
-    }
-  }
+    digitalWrite(_csPin, LOW);
+
+    // Send READ RX BUFFER instruction for RXBnD0(n).
+    SPI.transfer(0b10010010 + (n * 0x04));
+    // Get the data.
+    for (uint8_t i = 0; i < _rxLength; i++)
+      _rxData[i] = SPI.transfer(0x00);
 
-  modifyRegister(REG_CANINTF, FLAG_RXnIF(n), 0x00);
+    digitalWrite(_csPin, HIGH);
 
+    // Don't need to unset the RXnIF(n) flag as this is done automatically when
+    // setting the CS high after a READ RX BUFFER instruction.
+  }
+
+  SPI.endTransaction();
   return _rxDlc;
 }