Split out common code to new CANController class, add MCP2515 specific class

Author: sandeepmistry

src/CAN.h

@@ -4,88 +4,6 @@
 #ifndef CAN_H
 #define CAN_H
 
-#include <Arduino.h>
-#include <SPI.h>
-
-#define CAN_DEFAULT_CLOCK_FREQUENCY 16e6
-#define CAN_DEFAULT_SS_PIN          10
-#define CAN_DEFAULT_INT_PIN         2
-
-class CANClass : public Stream {
-
-public:
-  CANClass();
-
-  int begin(long baudRate);
-  void end();
-
-  int beginPacket(int id, int dlc = -1, bool rtr = false);
-  int beginExtendedPacket(long id, int dlc = -1, bool rtr = false);
-  int endPacket();
-
-  int parsePacket();
-  long packetId();
-  bool packetExtended();
-  bool packetRtr();
-  int packetDlc();
-
-  // from Print
-  virtual size_t write(uint8_t byte);
-  virtual size_t write(const uint8_t *buffer, size_t size);
-
-  // from Stream
-  virtual int available();
-  virtual int read();
-  virtual int peek();
-  virtual void flush();
-
-  void onReceive(void(*callback)(int));
-
-  int loopback();
-  int sleep();
-  int wakeup();
-
-  void setPins(int ss = CAN_DEFAULT_SS_PIN, int irq = CAN_DEFAULT_INT_PIN);
-  void setSPIFrequency(uint32_t frequency);
-  void setClockFrequency(long clockFrequency);
-
-  void dumpRegisters(Stream& out);
-
-private:
-  void reset();
-
-  void handleInterrupt();
-
-  uint8_t readRegister(uint8_t address);
-  void modifyRegister(uint8_t address, uint8_t mask, uint8_t value);
-  void writeRegister(uint8_t address, uint8_t value);
-
-  static void onInterrupt();
-
-private:
-  SPISettings _spiSettings;
-  int _ss;
-  int _irq;
-  long _clockFrequency;
-  void (*_onReceive)(int);
-
-  bool _packetBegun;
-  long _txId;
-  bool _txExtended;
-  bool _txRtr;
-  int _txDlc;
-  int _txLength;
-  uint8_t _txData[8];
-
-  long _rxId;
-  bool _rxExtended;
-  bool _rxRtr;
-  int _rxDlc;
-  int _rxLength;
-  int _rxIndex;
-  uint8_t _rxData[8];
-};
-
-extern CANClass CAN;
+#include "MCP2515.h"
 
 #endif

src/CANController.cpp

@@ -0,0 +1,206 @@
+// Copyright (c) Sandeep Mistry. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#include "CANController.h"
+
+CANControllerClass::CANControllerClass() :
+  _onReceive(NULL),
+
+  _packetBegun(false),
+  _txId(-1),
+  _txExtended(-1),
+  _txRtr(false),
+  _txDlc(0),
+  _txLength(0),
+
+  _rxId(-1),
+  _rxExtended(false),
+  _rxRtr(false),
+  _rxDlc(0),
+  _rxLength(0),
+  _rxIndex(0)
+{
+  // overide Stream timeout value
+  setTimeout(0);
+}
+
+CANControllerClass::~CANControllerClass()
+{
+}
+
+int CANControllerClass::begin(long /*baudRate*/)
+{
+  _packetBegun = false;
+  _txId = -1;
+  _txRtr =false;
+  _txDlc = 0;
+  _txLength = 0;
+
+  _rxId = -1;
+  _rxRtr = false;
+  _rxDlc = 0;
+  _rxLength = 0;
+  _rxIndex = 0;
+
+  return 1;
+}
+
+void CANControllerClass::end()
+{
+}
+
+int CANControllerClass::beginPacket(int id, int dlc, bool rtr)
+{
+  if (id < 0 || id > 0x7FF) {
+    return 0;
+  }
+
+  if (dlc > 8) {
+    return 0;
+  }
+
+  _packetBegun = true;
+  _txId = id;
+  _txExtended = false;
+  _txRtr = rtr;
+  _txDlc = dlc;
+  _txLength = 0;
+
+  memset(_txData, 0x00, sizeof(_txData));
+
+  return 1;
+}
+
+int CANControllerClass::beginExtendedPacket(long id, int dlc, bool rtr)
+{
+  if (id < 0 || id > 0x1FFFFFFF) {
+    return 0;
+  }
+
+  if (dlc > 8) {
+    return 0;
+  }
+
+  _packetBegun = true;
+  _txId = id;
+  _txExtended = true;
+  _txRtr = rtr;
+  _txDlc = dlc;
+  _txLength = 0;
+
+  memset(_txData, 0x00, sizeof(_txData));
+
+  return 1;
+}
+
+int CANControllerClass::endPacket()
+{
+  if (!_packetBegun) {
+    return 0;
+  }
+  _packetBegun = false;
+
+  if (_txDlc >= 0) {
+    _txLength = _txDlc;
+  }
+
+  return 1;
+}
+
+int CANControllerClass::parsePacket()
+{
+  return 0;
+}
+
+long CANControllerClass::packetId()
+{
+  return _rxId;
+}
+
+bool CANControllerClass::packetExtended()
+{
+  return _rxExtended;
+}
+
+bool CANControllerClass::packetRtr()
+{
+  return _rxRtr;
+}
+
+int CANControllerClass::packetDlc()
+{
+  return _rxDlc;
+}
+
+size_t CANControllerClass::write(uint8_t byte)
+{
+  return write(&byte, sizeof(byte));
+}
+
+size_t CANControllerClass::write(const uint8_t *buffer, size_t size)
+{
+  if (!_packetBegun) {
+    return 0;
+  }
+
+  if (size > (sizeof(_txData) - _txLength)) {
+    size = sizeof(_txData) - _txLength;
+  }
+
+  memcpy(&_txData[_txLength], buffer, size);
+  _txLength += size;
+
+  return size;
+}
+
+int CANControllerClass::available()
+{
+  return (_rxLength - _rxIndex);
+}
+
+int CANControllerClass::read()
+{
+  if (!available()) {
+    return -1;
+  }
+
+  return _rxData[_rxIndex++];
+}
+
+int CANControllerClass::peek()
+{
+  if (!available()) {
+    return -1;
+  }
+
+  return _rxData[_rxIndex];
+}
+
+void CANControllerClass::flush()
+{
+}
+
+void CANControllerClass::onReceive(void(*callback)(int))
+{
+  _onReceive = callback;
+}
+
+int CANControllerClass::observe()
+{
+  return 0;
+}
+
+int CANControllerClass::loopback()
+{
+  return 0;
+}
+
+int CANControllerClass::sleep()
+{
+  return 0;
+}
+
+int CANControllerClass::wakeup()
+{
+  return 0;
+}

src/CANController.h

@@ -0,0 +1,66 @@
+// Copyright (c) Sandeep Mistry. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#ifndef CAN_CONTROLLER_H
+#define CAN_CONTROLLER_H
+
+#include <Arduino.h>
+
+class CANControllerClass : public Stream {
+
+public:
+  virtual int begin(long baudRate);
+  virtual void end();
+
+  int beginPacket(int id, int dlc = -1, bool rtr = false);
+  int beginExtendedPacket(long id, int dlc = -1, bool rtr = false);
+  virtual int endPacket();
+
+  virtual int parsePacket();
+  long packetId();
+  bool packetExtended();
+  bool packetRtr();
+  int packetDlc();
+
+  // from Print
+  virtual size_t write(uint8_t byte);
+  virtual size_t write(const uint8_t *buffer, size_t size);
+
+  // from Stream
+  virtual int available();
+  virtual int read();
+  virtual int peek();
+  virtual void flush();
+
+  virtual void onReceive(void(*callback)(int));
+
+  virtual int observe();
+  virtual int loopback();
+  virtual int sleep();
+  virtual int wakeup();
+
+protected:
+  CANControllerClass();
+  virtual ~CANControllerClass();
+
+protected:
+  void (*_onReceive)(int);
+
+  bool _packetBegun;
+  long _txId;
+  bool _txExtended;
+  bool _txRtr;
+  int _txDlc;
+  int _txLength;
+  uint8_t _txData[8];
+
+  long _rxId;
+  bool _rxExtended;
+  bool _rxRtr;
+  int _rxDlc;
+  int _rxLength;
+  int _rxIndex;
+  uint8_t _rxData[8];
+};
+
+#endif