SPI: allow inheritance from SPIClass

facchinm · facchinm · commit 000db0c4b800 · 2021-11-09T09:54:57.000+01:00
diff --git a/libraries/SPI/SPI.cpp b/libraries/SPI/SPI.cpp
@@ -48,7 +48,7 @@ static inline SercomSpiClockMode getDataMode(SPISettings& settings) {
     }
 }
 
-SPIClass::SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI, SercomSpiTXPad PadTx, SercomRXPad PadRx)
+SPIClassSAMD::SPIClassSAMD(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI, SercomSpiTXPad PadTx, SercomRXPad PadRx)
 : settings(0, MSBFIRST, SPI_MODE0)
 {
   initialized = false;
@@ -65,7 +65,7 @@ SPIClass::SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint
   _padRx=PadRx;
 }
 
-void SPIClass::begin()
+void SPIClassSAMD::begin()
 {
   init();
 
@@ -77,7 +77,7 @@ void SPIClass::begin()
   config(DEFAULT_SPI_SETTINGS);
 }
 
-void SPIClass::init()
+void SPIClassSAMD::init()
 {
   if (initialized)
     return;
@@ -87,7 +87,7 @@ void SPIClass::init()
   initialized = true;
 }
 
-void SPIClass::config(SPISettings settings)
+void SPIClassSAMD::config(SPISettings settings)
 {
   if (this->settings != settings) {
     this->settings = settings;
@@ -105,7 +105,7 @@ void SPIClass::config(SPISettings settings)
   }
 }
 
-void SPIClass::end()
+void SPIClassSAMD::end()
 {
   _p_sercom->resetSPI();
   initialized = false;
@@ -121,7 +121,7 @@ static inline unsigned char __interruptsStatus(void)
 }
 #endif
 
-void SPIClass::usingInterrupt(int interruptNumber)
+void SPIClassSAMD::usingInterrupt(int interruptNumber)
 {
   if ((interruptNumber == NOT_AN_INTERRUPT) || (interruptNumber == EXTERNAL_INT_NMI))
     return;
@@ -141,7 +141,7 @@ void SPIClass::usingInterrupt(int interruptNumber)
     interrupts();
 }
 
-void SPIClass::notUsingInterrupt(int interruptNumber)
+void SPIClassSAMD::notUsingInterrupt(int interruptNumber)
 {
   if ((interruptNumber == NOT_AN_INTERRUPT) || (interruptNumber == EXTERNAL_INT_NMI))
     return;
@@ -161,7 +161,7 @@ void SPIClass::notUsingInterrupt(int interruptNumber)
     interrupts();
 }
 
-void SPIClass::beginTransaction(SPISettings settings)
+void SPIClassSAMD::beginTransaction(SPISettings settings)
 {
   if (interruptMode != SPI_IMODE_NONE)
   {
@@ -177,7 +177,7 @@ void SPIClass::beginTransaction(SPISettings settings)
   config(settings);
 }
 
-void SPIClass::endTransaction(void)
+void SPIClassSAMD::endTransaction(void)
 {
   if (interruptMode != SPI_IMODE_NONE)
   {
@@ -191,7 +191,7 @@ void SPIClass::endTransaction(void)
   }
 }
 
-void SPIClass::setBitOrder(BitOrder order)
+void SPIClassSAMD::setBitOrder(BitOrder order)
 {
   if (order == LSBFIRST) {
     _p_sercom->setDataOrderSPI(LSB_FIRST);
@@ -200,7 +200,7 @@ void SPIClass::setBitOrder(BitOrder order)
   }
 }
 
-void SPIClass::setDataMode(uint8_t mode)
+void SPIClassSAMD::setDataMode(uint8_t mode)
 {
   switch (mode)
   {
@@ -225,7 +225,7 @@ void SPIClass::setDataMode(uint8_t mode)
   }
 }
 
-void SPIClass::setClockDivider(uint8_t div)
+void SPIClassSAMD::setClockDivider(uint8_t div)
 {
   if (div < SPI_MIN_CLOCK_DIVIDER) {
     _p_sercom->setBaudrateSPI(SPI_MIN_CLOCK_DIVIDER);
@@ -234,12 +234,12 @@ void SPIClass::setClockDivider(uint8_t div)
   }
 }
 
-byte SPIClass::transfer(uint8_t data)
+byte SPIClassSAMD::transfer(uint8_t data)
 {
   return _p_sercom->transferDataSPI(data);
 }
 
-uint16_t SPIClass::transfer16(uint16_t data) {
+uint16_t SPIClassSAMD::transfer16(uint16_t data) {
   union { uint16_t val; struct { uint8_t lsb; uint8_t msb; }; } t;
 
   t.val = data;
@@ -255,7 +255,7 @@ uint16_t SPIClass::transfer16(uint16_t data) {
   return t.val;
 }
 
-void SPIClass::transfer(void *buf, size_t count)
+void SPIClassSAMD::transfer(void *buf, size_t count)
 {
   uint8_t *buffer = reinterpret_cast<uint8_t *>(buf);
   for (size_t i=0; i<count; i++) {
@@ -264,11 +264,11 @@ void SPIClass::transfer(void *buf, size_t count)
   }
 }
 
-void SPIClass::attachInterrupt() {
+void SPIClassSAMD::attachInterrupt() {
   // Should be enableInterrupt()
 }
 
-void SPIClass::detachInterrupt() {
+void SPIClassSAMD::detachInterrupt() {
   // Should be disableInterrupt()
 }
 
@@ -287,21 +287,21 @@ void SPIClass::detachInterrupt() {
     #define PAD_SPI_TX           SPI_PAD_2_SCK_3
     #define PAD_SPI_RX           SERCOM_RX_PAD_0
   #endif // PERIPH_SPI
-  SPIClass SPI (&PERIPH_SPI,  PIN_SPI_MISO,  PIN_SPI_SCK,  PIN_SPI_MOSI,  PAD_SPI_TX,  PAD_SPI_RX);
+  SPIClassSAMD SPI (&PERIPH_SPI,  PIN_SPI_MISO,  PIN_SPI_SCK,  PIN_SPI_MOSI,  PAD_SPI_TX,  PAD_SPI_RX);
 #endif
 #if SPI_INTERFACES_COUNT > 1
-  SPIClass SPI1(&PERIPH_SPI1, PIN_SPI1_MISO, PIN_SPI1_SCK, PIN_SPI1_MOSI, PAD_SPI1_TX, PAD_SPI1_RX);
+  SPIClassSAMD SPI1(&PERIPH_SPI1, PIN_SPI1_MISO, PIN_SPI1_SCK, PIN_SPI1_MOSI, PAD_SPI1_TX, PAD_SPI1_RX);
 #endif
 #if SPI_INTERFACES_COUNT > 2
-  SPIClass SPI2(&PERIPH_SPI2, PIN_SPI2_MISO, PIN_SPI2_SCK, PIN_SPI2_MOSI, PAD_SPI2_TX, PAD_SPI2_RX);
+  SPIClassSAMD SPI2(&PERIPH_SPI2, PIN_SPI2_MISO, PIN_SPI2_SCK, PIN_SPI2_MOSI, PAD_SPI2_TX, PAD_SPI2_RX);
 #endif
 #if SPI_INTERFACES_COUNT > 3
-  SPIClass SPI3(&PERIPH_SPI3, PIN_SPI3_MISO, PIN_SPI3_SCK, PIN_SPI3_MOSI, PAD_SPI3_TX, PAD_SPI3_RX);
+  SPIClassSAMD SPI3(&PERIPH_SPI3, PIN_SPI3_MISO, PIN_SPI3_SCK, PIN_SPI3_MOSI, PAD_SPI3_TX, PAD_SPI3_RX);
 #endif
 #if SPI_INTERFACES_COUNT > 4
-  SPIClass SPI4(&PERIPH_SPI4, PIN_SPI4_MISO, PIN_SPI4_SCK, PIN_SPI4_MOSI, PAD_SPI4_TX, PAD_SPI4_RX);
+  SPIClassSAMD SPI4(&PERIPH_SPI4, PIN_SPI4_MISO, PIN_SPI4_SCK, PIN_SPI4_MOSI, PAD_SPI4_TX, PAD_SPI4_RX);
 #endif
 #if SPI_INTERFACES_COUNT > 5
-  SPIClass SPI5(&PERIPH_SPI5, PIN_SPI5_MISO, PIN_SPI5_SCK, PIN_SPI5_MOSI, PAD_SPI5_TX, PAD_SPI5_RX);
+  SPIClassSAMD SPI5(&PERIPH_SPI5, PIN_SPI5_MISO, PIN_SPI5_SCK, PIN_SPI5_MOSI, PAD_SPI5_TX, PAD_SPI5_RX);
 #endif
 
diff --git a/libraries/SPI/SPI.h b/libraries/SPI/SPI.h
@@ -87,25 +87,25 @@ class SPIClassSAMD : public arduino::HardwareSPI {
   uint32_t interruptMask;
 };
 
-#define SPIClass SPIClassSAMD
+//#define SPIClass SPIClassSAMD
 
 #if SPI_INTERFACES_COUNT > 0
-  extern SPIClass SPI;
+  extern SPIClassSAMD SPI;
 #endif
 #if SPI_INTERFACES_COUNT > 1
-  extern SPIClass SPI1;
+  extern SPIClassSAMD SPI1;
 #endif
 #if SPI_INTERFACES_COUNT > 2
-  extern SPIClass SPI2;
+  extern SPIClassSAMD SPI2;
 #endif
 #if SPI_INTERFACES_COUNT > 3
-  extern SPIClass SPI3;
+  extern SPIClassSAMD SPI3;
 #endif
 #if SPI_INTERFACES_COUNT > 4
-  extern SPIClass SPI4;
+  extern SPIClassSAMD SPI4;
 #endif
 #if SPI_INTERFACES_COUNT > 5
-  extern SPIClass SPI5;
+  extern SPIClassSAMD SPI5;
 #endif
 
 // For compatibility with sketches designed for AVR @ 16 MHz

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ static inline SercomSpiClockMode getDataMode(SPISettings& settings) {`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`-SPIClass::SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI, SercomSpiTXPad PadTx, SercomRXPad PadRx)`
	`51`	`+SPIClassSAMD::SPIClassSAMD(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI, SercomSpiTXPad PadTx, SercomRXPad PadRx)`
`52`	`52`	`: settings(0, MSBFIRST, SPI_MODE0)`
`53`	`53`	`{`
`54`	`54`	`initialized = false;`
`@@ -65,7 +65,7 @@ SPIClass::SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint`
`65`	`65`	`_padRx=PadRx;`
`66`	`66`	`}`
`67`	`67`
`68`		`-void SPIClass::begin()`
	`68`	`+void SPIClassSAMD::begin()`
`69`	`69`	`{`
`70`	`70`	`init();`
`71`	`71`
`@@ -77,7 +77,7 @@ void SPIClass::begin()`
`77`	`77`	`config(DEFAULT_SPI_SETTINGS);`
`78`	`78`	`}`
`79`	`79`
`80`		`-void SPIClass::init()`
	`80`	`+void SPIClassSAMD::init()`
`81`	`81`	`{`
`82`	`82`	`if (initialized)`
`83`	`83`	`return;`
`@@ -87,7 +87,7 @@ void SPIClass::init()`
`87`	`87`	`initialized = true;`
`88`	`88`	`}`
`89`	`89`
`90`		`-void SPIClass::config(SPISettings settings)`
	`90`	`+void SPIClassSAMD::config(SPISettings settings)`
`91`	`91`	`{`
`92`	`92`	`if (this->settings != settings) {`
`93`	`93`	`this->settings = settings;`
`@@ -105,7 +105,7 @@ void SPIClass::config(SPISettings settings)`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`108`		`-void SPIClass::end()`
	`108`	`+void SPIClassSAMD::end()`
`109`	`109`	`{`
`110`	`110`	`_p_sercom->resetSPI();`
`111`	`111`	`initialized = false;`
`@@ -121,7 +121,7 @@ static inline unsigned char __interruptsStatus(void)`
`121`	`121`	`}`
`122`	`122`	`#endif`
`123`	`123`
`124`		`-void SPIClass::usingInterrupt(int interruptNumber)`
	`124`	`+void SPIClassSAMD::usingInterrupt(int interruptNumber)`
`125`	`125`	`{`
`126`	`126`	`if ((interruptNumber == NOT_AN_INTERRUPT) \|\| (interruptNumber == EXTERNAL_INT_NMI))`
`127`	`127`	`return;`
`@@ -141,7 +141,7 @@ void SPIClass::usingInterrupt(int interruptNumber)`
`141`	`141`	`interrupts();`
`142`	`142`	`}`
`143`	`143`
`144`		`-void SPIClass::notUsingInterrupt(int interruptNumber)`
	`144`	`+void SPIClassSAMD::notUsingInterrupt(int interruptNumber)`
`145`	`145`	`{`
`146`	`146`	`if ((interruptNumber == NOT_AN_INTERRUPT) \|\| (interruptNumber == EXTERNAL_INT_NMI))`
`147`	`147`	`return;`
`@@ -161,7 +161,7 @@ void SPIClass::notUsingInterrupt(int interruptNumber)`
`161`	`161`	`interrupts();`
`162`	`162`	`}`
`163`	`163`
`164`		`-void SPIClass::beginTransaction(SPISettings settings)`
	`164`	`+void SPIClassSAMD::beginTransaction(SPISettings settings)`
`165`	`165`	`{`
`166`	`166`	`if (interruptMode != SPI_IMODE_NONE)`
`167`	`167`	`{`
`@@ -177,7 +177,7 @@ void SPIClass::beginTransaction(SPISettings settings)`
`177`	`177`	`config(settings);`
`178`	`178`	`}`
`179`	`179`
`180`		`-void SPIClass::endTransaction(void)`
	`180`	`+void SPIClassSAMD::endTransaction(void)`
`181`	`181`	`{`
`182`	`182`	`if (interruptMode != SPI_IMODE_NONE)`
`183`	`183`	`{`
`@@ -191,7 +191,7 @@ void SPIClass::endTransaction(void)`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`
`194`		`-void SPIClass::setBitOrder(BitOrder order)`
	`194`	`+void SPIClassSAMD::setBitOrder(BitOrder order)`
`195`	`195`	`{`
`196`	`196`	`if (order == LSBFIRST) {`
`197`	`197`	`_p_sercom->setDataOrderSPI(LSB_FIRST);`
`@@ -200,7 +200,7 @@ void SPIClass::setBitOrder(BitOrder order)`
`200`	`200`	`}`
`201`	`201`	`}`
`202`	`202`
`203`		`-void SPIClass::setDataMode(uint8_t mode)`
	`203`	`+void SPIClassSAMD::setDataMode(uint8_t mode)`
`204`	`204`	`{`
`205`	`205`	`switch (mode)`
`206`	`206`	`{`
`@@ -225,7 +225,7 @@ void SPIClass::setDataMode(uint8_t mode)`
`225`	`225`	`}`
`226`	`226`	`}`
`227`	`227`
`228`		`-void SPIClass::setClockDivider(uint8_t div)`
	`228`	`+void SPIClassSAMD::setClockDivider(uint8_t div)`
`229`	`229`	`{`
`230`	`230`	`if (div < SPI_MIN_CLOCK_DIVIDER) {`
`231`	`231`	`_p_sercom->setBaudrateSPI(SPI_MIN_CLOCK_DIVIDER);`
`@@ -234,12 +234,12 @@ void SPIClass::setClockDivider(uint8_t div)`
`234`	`234`	`}`
`235`	`235`	`}`
`236`	`236`
`237`		`-byte SPIClass::transfer(uint8_t data)`
	`237`	`+byte SPIClassSAMD::transfer(uint8_t data)`
`238`	`238`	`{`
`239`	`239`	`return _p_sercom->transferDataSPI(data);`
`240`	`240`	`}`
`241`	`241`
`242`		`-uint16_t SPIClass::transfer16(uint16_t data) {`
	`242`	`+uint16_t SPIClassSAMD::transfer16(uint16_t data) {`
`243`	`243`	`union { uint16_t val; struct { uint8_t lsb; uint8_t msb; }; } t;`
`244`	`244`
`245`	`245`	`t.val = data;`
`@@ -255,7 +255,7 @@ uint16_t SPIClass::transfer16(uint16_t data) {`
`255`	`255`	`return t.val;`
`256`	`256`	`}`
`257`	`257`
`258`		`-void SPIClass::transfer(void *buf, size_t count)`
	`258`	`+void SPIClassSAMD::transfer(void *buf, size_t count)`
`259`	`259`	`{`
`260`	`260`	`uint8_t buffer = reinterpret_cast<uint8_t >(buf);`
`261`	`261`	`for (size_t i=0; i<count; i++) {`
`@@ -264,11 +264,11 @@ void SPIClass::transfer(void *buf, size_t count)`
`264`	`264`	`}`
`265`	`265`	`}`
`266`	`266`
`267`		`-void SPIClass::attachInterrupt() {`
	`267`	`+void SPIClassSAMD::attachInterrupt() {`
`268`	`268`	`// Should be enableInterrupt()`
`269`	`269`	`}`
`270`	`270`
`271`		`-void SPIClass::detachInterrupt() {`
	`271`	`+void SPIClassSAMD::detachInterrupt() {`
`272`	`272`	`// Should be disableInterrupt()`
`273`	`273`	`}`
`274`	`274`
`@@ -287,21 +287,21 @@ void SPIClass::detachInterrupt() {`
`287`	`287`	`#define PAD_SPI_TX SPI_PAD_2_SCK_3`
`288`	`288`	`#define PAD_SPI_RX SERCOM_RX_PAD_0`
`289`	`289`	`#endif // PERIPH_SPI`
`290`		`- SPIClass SPI (&PERIPH_SPI, PIN_SPI_MISO, PIN_SPI_SCK, PIN_SPI_MOSI, PAD_SPI_TX, PAD_SPI_RX);`
	`290`	`+ SPIClassSAMD SPI (&PERIPH_SPI, PIN_SPI_MISO, PIN_SPI_SCK, PIN_SPI_MOSI, PAD_SPI_TX, PAD_SPI_RX);`
`291`	`291`	`#endif`
`292`	`292`	`#if SPI_INTERFACES_COUNT > 1`
`293`		`- SPIClass SPI1(&PERIPH_SPI1, PIN_SPI1_MISO, PIN_SPI1_SCK, PIN_SPI1_MOSI, PAD_SPI1_TX, PAD_SPI1_RX);`
	`293`	`+ SPIClassSAMD SPI1(&PERIPH_SPI1, PIN_SPI1_MISO, PIN_SPI1_SCK, PIN_SPI1_MOSI, PAD_SPI1_TX, PAD_SPI1_RX);`
`294`	`294`	`#endif`
`295`	`295`	`#if SPI_INTERFACES_COUNT > 2`
`296`		`- SPIClass SPI2(&PERIPH_SPI2, PIN_SPI2_MISO, PIN_SPI2_SCK, PIN_SPI2_MOSI, PAD_SPI2_TX, PAD_SPI2_RX);`
	`296`	`+ SPIClassSAMD SPI2(&PERIPH_SPI2, PIN_SPI2_MISO, PIN_SPI2_SCK, PIN_SPI2_MOSI, PAD_SPI2_TX, PAD_SPI2_RX);`
`297`	`297`	`#endif`
`298`	`298`	`#if SPI_INTERFACES_COUNT > 3`
`299`		`- SPIClass SPI3(&PERIPH_SPI3, PIN_SPI3_MISO, PIN_SPI3_SCK, PIN_SPI3_MOSI, PAD_SPI3_TX, PAD_SPI3_RX);`
	`299`	`+ SPIClassSAMD SPI3(&PERIPH_SPI3, PIN_SPI3_MISO, PIN_SPI3_SCK, PIN_SPI3_MOSI, PAD_SPI3_TX, PAD_SPI3_RX);`
`300`	`300`	`#endif`
`301`	`301`	`#if SPI_INTERFACES_COUNT > 4`
`302`		`- SPIClass SPI4(&PERIPH_SPI4, PIN_SPI4_MISO, PIN_SPI4_SCK, PIN_SPI4_MOSI, PAD_SPI4_TX, PAD_SPI4_RX);`
	`302`	`+ SPIClassSAMD SPI4(&PERIPH_SPI4, PIN_SPI4_MISO, PIN_SPI4_SCK, PIN_SPI4_MOSI, PAD_SPI4_TX, PAD_SPI4_RX);`
`303`	`303`	`#endif`
`304`	`304`	`#if SPI_INTERFACES_COUNT > 5`
`305`		`- SPIClass SPI5(&PERIPH_SPI5, PIN_SPI5_MISO, PIN_SPI5_SCK, PIN_SPI5_MOSI, PAD_SPI5_TX, PAD_SPI5_RX);`
	`305`	`+ SPIClassSAMD SPI5(&PERIPH_SPI5, PIN_SPI5_MISO, PIN_SPI5_SCK, PIN_SPI5_MOSI, PAD_SPI5_TX, PAD_SPI5_RX);`
`306`	`306`	`#endif`
`307`	`307`