Skip to content

Commit 99929f3

Browse files
pierremolinaropierremolinaro
committed
CS optimization (PR #31 and PR #32)
1 parent fddd798 commit 99929f3

File tree

4 files changed

+123
-124
lines changed

4 files changed

+123
-124
lines changed

‎extras/acan2517FD.pdf‎

-85 Bytes
Binary file not shown.

‎library.properties‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
name=ACAN2517FD
2-
version=2.1.9
2+
version=2.1.10
33
author=Pierre Molinaro
44
maintainer=Pierre Molinaro <Pierre.Molinaro@pcmolinaro.name>
55
sentence=Driver for MCP2517FD and MCP2518FD CAN Controller (CAN FD mode)

‎src/ACAN2517FD.cpp‎

Lines changed: 9 additions & 121 deletions
Original file line numberDiff line numberDiff line change
@@ -276,17 +276,17 @@ uint32_t ACAN2517FD::begin (const ACAN2517FDSettings & inSettings,
276276
if (mINT != 255) { // 255 means interrupt is not used (thanks to Tyler Lewis)
277277
pinMode (mINT, INPUT_PULLUP) ;
278278
}
279-
initCS(mCS);
279+
initCS () ;
280280
//----------------------------------- Set SPI clock to 1 MHz
281281
mSPISettings = SPISettings (1000UL * 1000, MSBFIRST, SPI_MODE0) ;
282282
//----------------------------------- Request configuration mode
283283
bool wait = true ;
284-
const uint32_t startTime = millis () ;
284+
const uint32_t startTime = millis () ;
285285
while (wait) {
286286
writeRegister8 (CON_REGISTER + 3, 0x04 | (1 << 3)) ; // Request configuration mode, abort all transmissions
287287
const uint8_t actualMode = (readRegister8 (CON_REGISTER + 2) >> 5) & 0x07 ;
288288
wait = actualMode != 0x04 ;
289-
if (wait && (millis () - startTime > 2)) { // Wait (2 ms max) until the configuration mode is reached
289+
if (wait && ((millis () - startTime) > 2)) { // Wait (2 ms max) until the configuration mode is reached
290290
errorCode |= kRequestedConfigurationModeTimeOut ;
291291
wait = false ;
292292
}
@@ -340,7 +340,7 @@ uint32_t ACAN2517FD::begin (const ACAN2517FDSettings & inSettings,
340340
const uint32_t startTime = millis () ;
341341
while (wait) {
342342
wait = (readRegister8 (OSC_REGISTER + 1) & 0x1) == 0 ; // DS20005688B, page 16
343-
if (wait && (millis () - startTime > 2)) {
343+
if (wait && ((millis () - startTime) > 2)) {
344344
errorCode = kX10PLLNotReadyWithin1MS ;
345345
wait = false ;
346346
}
@@ -491,11 +491,11 @@ uint32_t ACAN2517FD::begin (const ACAN2517FDSettings & inSettings,
491491
writeRegister8 (CON_REGISTER + 3, mTXBWS_RequestedMode);
492492
//----------------------------------- Wait (10 ms max) until requested mode is reached
493493
bool wait = true ;
494-
const uint32_t startTime () ;
494+
const uint32_t startTime = millis () ;
495495
while (wait) {
496496
const uint8_t actualMode = (readRegister8 (CON_REGISTER + 2) >> 5) & 0x07 ;
497497
wait = actualMode != inSettings.mRequestedMode ;
498-
if (wait && (millis () - startTime > 10) {
498+
if (wait && ((millis () - startTime) > 10)) {
499499
errorCode |= kRequestedModeTimeOut ;
500500
wait = false ;
501501
}
@@ -539,13 +539,13 @@ bool ACAN2517FD::end (void) {
539539
//--- Request configuration mode
540540
bool wait = true ;
541541
bool ok = false ;
542-
const uint32_t startTime = millis () ;
542+
const uint32_t startTime = millis () ;
543543
while (wait) {
544544
writeRegister8Assume_SPI_transaction (CON_REGISTER + 3, 0x04 | (1 << 3)) ; // Request configuration mode, abort all transmissions
545545
const uint8_t actualMode = (readRegister8Assume_SPI_transaction (CON_REGISTER + 2) >> 5) & 0x07 ;
546546
ok = actualMode == 0x04 ;
547547
wait = !ok ;
548-
if (wait && (millis () - startTime > 2)) { // Wait (2 ms max) until the configuration mode is reached
548+
if (wait && ((millis () - startTime) > 2)) { // Wait (2 ms max) until the configuration mode is reached
549549
wait = false ;
550550
}
551551
}
@@ -1013,118 +1013,6 @@ void ACAN2517FD::receiveInterrupt (void) {
10131013
// MCP2517FD REGISTER ACCESS, SECOND LEVEL FUNCTIONS (HANDLE CS, ASSUME WITHIN SPI TRANSACTION)
10141014
//----------------------------------------------------------------------------------------------------------------------
10151015

1016-
#if defined(__AVR__)
1017-
static volatile uint8_t *cs_pin_reg;
1018-
static uint8_t cs_pin_mask;
1019-
inline static void initCS(uint8_t cs_pin) {
1020-
cs_pin_reg = portOutputRegister(digitalPinToPort(cs_pin));
1021-
cs_pin_mask = digitalPinToBitMask(cs_pin);
1022-
pinMode(cs_pin, OUTPUT);
1023-
}
1024-
inline static void assertCS() {
1025-
*(cs_pin_reg) &= ~cs_pin_mask;
1026-
}
1027-
inline static void deassertCS() {
1028-
*(cs_pin_reg) |= cs_pin_mask;
1029-
}
1030-
#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
1031-
static volatile uint8_t *cs_pin_reg;
1032-
inline static void initCS(uint8_t cs_pin) {
1033-
cs_pin_reg = portOutputRegister(cs_pin);
1034-
pinMode(cs_pin, OUTPUT);
1035-
}
1036-
inline static void assertCS() {
1037-
*(cs_pin_reg+256) = 1;
1038-
}
1039-
inline static void deassertCS() {
1040-
*(cs_pin_reg+128) = 1;
1041-
}
1042-
#elif defined(__MKL26Z64__)
1043-
static volatile uint8_t *cs_pin_reg;
1044-
static uint8_t cs_pin_mask;
1045-
inline static void initCS(uint8_t cs_pin) {
1046-
cs_pin_reg = portOutputRegister(digitalPinToPort(cs_pin));
1047-
cs_pin_mask = digitalPinToBitMask(cs_pin);
1048-
pinMode(cs_pin, OUTPUT);
1049-
}
1050-
inline static void assertCS() {
1051-
*(cs_pin_reg+8) = cs_pin_mask;
1052-
}
1053-
inline static void deassertCS() {
1054-
*(cs_pin_reg+4) = cs_pin_mask;
1055-
}
1056-
#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__)
1057-
static volatile uint32_t *cs_pin_reg;
1058-
static uint32_t cs_pin_mask;
1059-
inline static void initCS(uint8_t cs_pin) {
1060-
cs_pin_reg = &(digitalPinToPort(cs_pin)->PIO_PER);
1061-
cs_pin_mask = digitalPinToBitMask(cs_pin);
1062-
pinMode(cs_pin, OUTPUT);
1063-
}
1064-
inline static void assertCS() {
1065-
*(cs_pin_reg+13) = cs_pin_mask;
1066-
}
1067-
inline static void deassertCS() {
1068-
*(cs_pin_reg+12) = cs_pin_mask;
1069-
}
1070-
#elif defined(__PIC32MX__)
1071-
static volatile uint32_t *cs_pin_reg;
1072-
static uint32_t cs_pin_mask;
1073-
inline static void initCS(uint8_t cs_pin) {
1074-
cs_pin_reg = portModeRegister(digitalPinToPort(cs_pin));
1075-
cs_pin_mask = digitalPinToBitMask(cs_pin);
1076-
pinMode(cs_pin, OUTPUT);
1077-
}
1078-
inline static void assertCS() {
1079-
*(cs_pin_reg+8+1) = cs_pin_mask;
1080-
}
1081-
inline static void deassertCS() {
1082-
*(cs_pin_reg+8+2) = cs_pin_mask;
1083-
}
1084-
1085-
#elif defined(ARDUINO_ARCH_ESP8266)
1086-
static volatile uint32_t *cs_pin_reg;
1087-
static uint32_t cs_pin_mask;
1088-
inline static void initCS(uint8_t cs_pin) {
1089-
cs_pin_reg = (volatile uint32_t*)GPO;
1090-
cs_pin_mask = 1 << cs_pin;
1091-
pinMode(cs_pin, OUTPUT);
1092-
}
1093-
inline static void assertCS() {
1094-
GPOC = cs_pin_mask;
1095-
}
1096-
inline static void deassertCS() {
1097-
GPOS = cs_pin_mask;
1098-
}
1099-
1100-
#elif defined(__SAMD21G18A__)
1101-
static volatile uint32_t *cs_pin_reg;
1102-
static uint32_t cs_pin_mask;
1103-
inline static void initCS(uint8_t cs_pin) {
1104-
cs_pin_reg = portModeRegister(digitalPinToPort(cs_pin));
1105-
cs_pin_mask = digitalPinToBitMask(cs_pin);
1106-
pinMode(cs_pin, OUTPUT);
1107-
}
1108-
inline static void assertCS() {
1109-
*(cs_pin_reg+5) = cs_pin_mask;
1110-
}
1111-
inline static void deassertCS() {
1112-
*(cs_pin_reg+6) = cs_pin_mask;
1113-
}
1114-
#else
1115-
inline static void initCS(uint8_t cs_pin) {
1116-
pinMode(cs_pin, OUTPUT);
1117-
}
1118-
inline static void assertCS() {
1119-
digitalWrite(cs_pin, LOW);
1120-
}
1121-
inline static void deassertCS() {
1122-
digitalWrite(cs_pin, HIGH);
1123-
}
1124-
#endif
1125-
1126-
//----------------------------------------------------------------------------------------------------------------------
1127-
11281016
void ACAN2517FD::writeRegister32Assume_SPI_transaction (const uint16_t inRegisterAddress,
11291017
const uint32_t inValue) {
11301018
//--- Write word register via 6-byte buffer (speed enhancement, thanks to thomasfla)
@@ -1328,7 +1216,7 @@ bool ACAN2517FD::recoverFromRestrictedOperationMode (void) {
13281216
const uint8_t actualMode = (readRegister8 (CON_REGISTER + 2) >> 5) & 0x07 ;
13291217
wait = actualMode != (mTXBWS_RequestedMode & 0x07) ;
13301218
recoveryDone = !wait ;
1331-
if (wait && (millis () - startTime > 10)) {
1219+
if (wait && ((millis () - startTime) > 10)) {
13321220
wait = false ;
13331221
}
13341222
}

‎src/ACAN2517FD.h‎

Lines changed: 113 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -180,8 +180,6 @@ class ACAN2517FD {
180180
private: uint32_t readRegister32Assume_SPI_transaction (const uint16_t inRegisterAddress) ;
181181
private: uint8_t readRegister8Assume_SPI_transaction (const uint16_t inRegisterAddress) ;
182182
private: uint16_t readRegister16Assume_SPI_transaction (const uint16_t inRegisterAddress) ;
183-
private: void assertCS (void) ;
184-
private: void deassertCS (void) ;
185183

186184
private: void reset2517FD (void) ;
187185

@@ -214,6 +212,119 @@ class ACAN2517FD {
214212
public: SemaphoreHandle_t mISRSemaphore ;
215213
#endif
216214

215+
//----------------------------------------------------------------------------------------------------------------------
216+
// Optimized CS handling (thanks to Flole998)
217+
//······················································································································
218+
219+
#if defined(__AVR__)
220+
private: volatile uint8_t *cs_pin_reg;
221+
private: uint8_t cs_pin_mask;
222+
private: inline void initCS () {
223+
cs_pin_reg = portOutputRegister(digitalPinToPort(mCS));
224+
cs_pin_mask = digitalPinToBitMask(mCS);
225+
pinMode(mCS, OUTPUT);
226+
}
227+
private: inline void assertCS() {
228+
*(cs_pin_reg) &= ~cs_pin_mask;
229+
}
230+
private: inline void deassertCS() {
231+
*(cs_pin_reg) |= cs_pin_mask;
232+
}
233+
#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
234+
private: volatile uint8_t *cs_pin_reg;
235+
private: inline void initCS () {
236+
cs_pin_reg = portOutputRegister(mCS);
237+
pinMode(mCS, OUTPUT);
238+
}
239+
private: inline void assertCS() {
240+
*(cs_pin_reg+256) = 1;
241+
}
242+
private: inline void deassertCS() {
243+
*(cs_pin_reg+128) = 1;
244+
}
245+
#elif defined(__MKL26Z64__)
246+
private: volatile uint8_t *cs_pin_reg;
247+
private: uint8_t cs_pin_mask;
248+
private: inline void initCS () {
249+
cs_pin_reg = portOutputRegister(digitalPinToPort(mCS));
250+
cs_pin_mask = digitalPinToBitMask(mCS);
251+
pinMode(mCS, OUTPUT);
252+
}
253+
private: inline void assertCS() {
254+
*(cs_pin_reg+8) = cs_pin_mask;
255+
}
256+
private: inline void deassertCS() {
257+
*(cs_pin_reg+4) = cs_pin_mask;
258+
}
259+
#elif defined(__SAM3X8E__) || defined(__SAM3A8C__) || defined(__SAM3A4C__)
260+
private: volatile uint32_t *cs_pin_reg;
261+
private: uint32_t cs_pin_mask;
262+
private: inline void initCS () {
263+
cs_pin_reg = &(digitalPinToPort(mCS)->PIO_PER);
264+
cs_pin_mask = digitalPinToBitMask(mCS);
265+
pinMode(mCS, OUTPUT);
266+
}
267+
private: inline void assertCS() {
268+
*(cs_pin_reg+13) = cs_pin_mask;
269+
}
270+
private: inline void deassertCS() {
271+
*(cs_pin_reg+12) = cs_pin_mask;
272+
}
273+
#elif defined(__PIC32MX__)
274+
private: volatile uint32_t *cs_pin_reg;
275+
private: uint32_t cs_pin_mask;
276+
private: inline void initCS () {
277+
cs_pin_reg = portModeRegister(digitalPinToPort(mCS));
278+
cs_pin_mask = digitalPinToBitMask(mCS);
279+
pinMode(mCS, OUTPUT);
280+
}
281+
private: inline void assertCS() {
282+
*(cs_pin_reg+8+1) = cs_pin_mask;
283+
}
284+
private: inline void deassertCS() {
285+
*(cs_pin_reg+8+2) = cs_pin_mask;
286+
}
287+
#elif defined(ARDUINO_ARCH_ESP8266)
288+
// private: volatile uint32_t *cs_pin_reg;
289+
private: uint32_t cs_pin_mask;
290+
private: inline void initCS () {
291+
// cs_pin_reg = (volatile uint32_t*)GPO;
292+
cs_pin_mask = 1 << mCS;
293+
pinMode(mCS, OUTPUT);
294+
}
295+
private: inline void assertCS() {
296+
GPOC = cs_pin_mask;
297+
}
298+
private: inline void deassertCS() {
299+
GPOS = cs_pin_mask;
300+
}
301+
302+
#elif defined(__SAMD21G18A__)
303+
private: volatile uint32_t *cs_pin_reg;
304+
private: uint32_t cs_pin_mask;
305+
private: inline void initCS () {
306+
cs_pin_reg = portModeRegister(digitalPinToPort(mCS));
307+
cs_pin_mask = digitalPinToBitMask(mCS);
308+
pinMode(mCS, OUTPUT);
309+
}
310+
private: inline void assertCS() {
311+
*(cs_pin_reg+5) = cs_pin_mask;
312+
}
313+
private: inline void deassertCS() {
314+
*(cs_pin_reg+6) = cs_pin_mask;
315+
}
316+
#else
317+
private: inline void initCS () {
318+
pinMode (mCS, OUTPUT);
319+
}
320+
private: inline void assertCS() {
321+
digitalWrite(mCS, LOW);
322+
}
323+
private: inline void deassertCS() {
324+
digitalWrite(mCS, HIGH);
325+
}
326+
#endif
327+
217328
//······················································································································
218329
// No copy
219330
//······················································································································

0 commit comments

Comments
 (0)