1  // Copyright (c) Sandeep Mistry. All rights reserved.
  2  // Licensed under the MIT license. See LICENSE file in the project root for full license information.
  3  
  4  #include "CANController.h"
  5  
  6  CANControllerClass::CANControllerClass() :
  7    _onReceive(NULL),
  8  
  9    _packetBegun(false),
 10    _txId(-1),
 11    _txExtended(-1),
 12    _txRtr(false),
 13    _txDlc(0),
 14    _txLength(0),
 15  
 16    _rxId(-1),
 17    _rxExtended(false),
 18    _rxRtr(false),
 19    _rxDlc(0),
 20    _rxLength(0),
 21    _rxIndex(0)
 22  {
 23    // overide Stream timeout value
 24    setTimeout(0);
 25  }
 26  
 27  CANControllerClass::~CANControllerClass()
 28  {
 29  }
 30  
 31  int CANControllerClass::begin(long /*baudRate*/)
 32  {
 33    _packetBegun = false;
 34    _txId = -1;
 35    _txRtr =false;
 36    _txDlc = 0;
 37    _txLength = 0;
 38  
 39    _rxId = -1;
 40    _rxRtr = false;
 41    _rxDlc = 0;
 42    _rxLength = 0;
 43    _rxIndex = 0;
 44  
 45    return 1;
 46  }
 47  
 48  void CANControllerClass::end()
 49  {
 50  }
 51  
 52  int CANControllerClass::beginPacket(int id, int dlc, bool rtr)
 53  {
 54    if (id < 0 || id > 0x7FF) {
 55      return 0;
 56    }
 57  
 58    if (dlc > 8) {
 59      return 0;
 60    }
 61  
 62    _packetBegun = true;
 63    _txId = id;
 64    _txExtended = false;
 65    _txRtr = rtr;
 66    _txDlc = dlc;
 67    _txLength = 0;
 68  
 69    memset(_txData, 0x00, sizeof(_txData));
 70  
 71    return 1;
 72  }
 73  
 74  int CANControllerClass::beginExtendedPacket(long id, int dlc, bool rtr)
 75  {
 76    if (id < 0 || id > 0x1FFFFFFF) {
 77      return 0;
 78    }
 79  
 80    if (dlc > 8) {
 81      return 0;
 82    }
 83  
 84    _packetBegun = true;
 85    _txId = id;
 86    _txExtended = true;
 87    _txRtr = rtr;
 88    _txDlc = dlc;
 89    _txLength = 0;
 90  
 91    memset(_txData, 0x00, sizeof(_txData));
 92  
 93    return 1;
 94  }
 95  
 96  int CANControllerClass::endPacket()
 97  {
 98    if (!_packetBegun) {
 99      return 0;
100    }
101    _packetBegun = false;
102  
103    if (_txDlc >= 0) {
104      _txLength = _txDlc;
105    }
106  
107    return 1;
108  }
109  
110  int CANControllerClass::parsePacket()
111  {
112    return 0;
113  }
114  
115  long CANControllerClass::packetId()
116  {
117    return _rxId;
118  }
119  
120  bool CANControllerClass::packetExtended()
121  {
122    return _rxExtended;
123  }
124  
125  bool CANControllerClass::packetRtr()
126  {
127    return _rxRtr;
128  }
129  
130  int CANControllerClass::packetDlc()
131  {
132    return _rxDlc;
133  }
134  
135  size_t CANControllerClass::write(uint8_t byte)
136  {
137    return write(&byte, sizeof(byte));
138  }
139  
140  size_t CANControllerClass::write(const uint8_t *buffer, size_t size)
141  {
142    if (!_packetBegun) {
143      return 0;
144    }
145  
146    if (size > (sizeof(_txData) - _txLength)) {
147      size = sizeof(_txData) - _txLength;
148    }
149  
150    memcpy(&_txData[_txLength], buffer, size);
151    _txLength += size;
152  
153    return size;
154  }
155  
156  int CANControllerClass::available()
157  {
158    return (_rxLength - _rxIndex);
159  }
160  
161  int CANControllerClass::read()
162  {
163    if (!available()) {
164      return -1;
165    }
166  
167    return _rxData[_rxIndex++];
168  }
169  
170  int CANControllerClass::peek()
171  {
172    if (!available()) {
173      return -1;
174    }
175  
176    return _rxData[_rxIndex];
177  }
178  
179  void CANControllerClass::flush()
180  {
181  }
182  
183  void CANControllerClass::onReceive(void(*callback)(int))
184  {
185    _onReceive = callback;
186  }
187  
188  int CANControllerClass::filter(int /*id*/, int /*mask*/)
189  {
190    return 0;
191  }
192  
193  int CANControllerClass::filterExtended(long /*id*/, long /*mask*/)
194  {
195    return 0;
196  }
197  
198  int CANControllerClass::observe()
199  {
200    return 0;
201  }
202  
203  int CANControllerClass::loopback()
204  {
205    return 0;
206  }
207  
208  int CANControllerClass::sleep()
209  {
210    return 0;
211  }
212  
213  int CANControllerClass::wakeup()
214  {
215    return 0;
216  }