Updating core to match Arduino samd release 1.6.19.

Author: jimblom

sparkfun/samd/cores/arduino/Print.cpp

@@ -238,14 +238,14 @@ size_t Print::printFloat(double number, uint8_t digits)
 
   // Print the decimal point, but only if there are digits beyond
   if (digits > 0) {
-    n += print(".");
+    n += print('.');
   }
 
   // Extract digits from the remainder one at a time
   while (digits-- > 0)
   {
     remainder *= 10.0;
-    unsigned int toPrint = (unsigned int)remainder;
+    unsigned int toPrint = (unsigned int)(remainder);
     n += print(toPrint);
     remainder -= toPrint;
   }

sparkfun/samd/cores/arduino/Print.h

@@ -28,6 +28,9 @@
 #define DEC 10
 #define HEX 16
 #define OCT 8
+#ifdef BIN // Prevent warnings if BIN is previously defined in "iotnx4.h" or similar
+#undef BIN
+#endif
 #define BIN 2
 
 class Print
@@ -54,6 +57,10 @@ class Print
       return write((const uint8_t *)buffer, size);
     }
 
+    // default to zero, meaning "a single write may block"
+    // should be overriden by subclasses with buffering
+    virtual int availableForWrite() { return 0; }
+
     size_t print(const __FlashStringHelper *);
     size_t print(const String &);
     size_t print(const char[]);
@@ -78,6 +85,8 @@ class Print
     size_t println(double, int = 2);
     size_t println(const Printable&);
     size_t println(void);
+
+    virtual void flush() { /* Empty implementation for backward compatibility */ }
 };
 
 #endif

sparkfun/samd/cores/arduino/RingBuffer.cpp

@@ -16,6 +16,8 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#ifdef __cplusplus
+
 #ifndef _RING_BUFFER_
 #define _RING_BUFFER_
 
@@ -27,24 +29,114 @@
 // location from which to read.
 #define SERIAL_BUFFER_SIZE 64
 
-class RingBuffer
+template <int N>
+class RingBufferN
 {
   public:
-    uint8_t _aucBuffer[SERIAL_BUFFER_SIZE] ;
-    int _iHead ;
-    int _iTail ;
+    uint8_t _aucBuffer[N] ;
+    volatile int _iHead ;
+    volatile int _iTail ;
 
   public:
-    RingBuffer( void ) ;
+    RingBufferN( void ) ;
     void store_char( uint8_t c ) ;
-	void clear();
-	int read_char();
-	int available();
-	int peek();
-	bool isFull();
+    void clear();
+    int read_char();
+    int available();
+    int availableForStore();
+    int peek();
+    bool isFull();
 
   private:
-	int nextIndex(int index);
-} ;
+    int nextIndex(int index);
+};
+
+typedef RingBufferN<SERIAL_BUFFER_SIZE> RingBuffer;
+
+
+template <int N>
+RingBufferN<N>::RingBufferN( void )
+{
+    memset( _aucBuffer, 0, N ) ;
+    clear();
+}
+
+template <int N>
+void RingBufferN<N>::store_char( uint8_t c )
+{
+  int i = nextIndex(_iHead);
+
+  // if we should be storing the received character into the location
+  // just before the tail (meaning that the head would advance to the
+  // current location of the tail), we're about to overflow the buffer
+  // and so we don't write the character or advance the head.
+  if ( i != _iTail )
+  {
+    _aucBuffer[_iHead] = c ;
+    _iHead = i ;
+  }
+}
+
+template <int N>
+void RingBufferN<N>::clear()
+{
+  _iHead = 0;
+  _iTail = 0;
+}
+
+template <int N>
+int RingBufferN<N>::read_char()
+{
+  if(_iTail == _iHead)
+    return -1;
+
+  uint8_t value = _aucBuffer[_iTail];
+  _iTail = nextIndex(_iTail);
+
+  return value;
+}
+
+template <int N>
+int RingBufferN<N>::available()
+{
+  int delta = _iHead - _iTail;
+
+  if(delta < 0)
+    return N + delta;
+  else
+    return delta;
+}
+
+template <int N>
+int RingBufferN<N>::availableForStore()
+{
+  if (_iHead >= _iTail)
+    return N - 1 - _iHead + _iTail;
+  else
+    return _iTail - _iHead - 1;
+}
+
+template <int N>
+int RingBufferN<N>::peek()
+{
+  if(_iTail == _iHead)
+    return -1;
+
+  return _aucBuffer[_iTail];
+}
+
+template <int N>
+int RingBufferN<N>::nextIndex(int index)
+{
+  return (uint32_t)(index + 1) % N;
+}
+
+template <int N>
+bool RingBufferN<N>::isFull()
+{
+  return (nextIndex(_iHead) == _iTail);
+}
 
 #endif /* _RING_BUFFER_ */
+
+#endif /* __cplusplus */

sparkfun/samd/cores/arduino/RingBuffer.h

@@ -19,6 +19,12 @@
 #include "SERCOM.h"
 #include "variant.h"
 
+#ifndef WIRE_RISE_TIME_NANOSECONDS
+// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+// you can override this value in your variant if needed
+#define WIRE_RISE_TIME_NANOSECONDS 125
+#endif
+
 SERCOM::SERCOM(Sercom* s)
 {
   sercom = s;
@@ -173,6 +179,16 @@ int SERCOM::writeDataUART(uint8_t data)
   return 1;
 }
 
+void SERCOM::enableDataRegisterEmptyInterruptUART()
+{
+  sercom->USART.INTENSET.reg = SERCOM_USART_INTENSET_DRE;
+}
+
+void SERCOM::disableDataRegisterEmptyInterruptUART()
+{
+  sercom->USART.INTENCLR.reg = SERCOM_USART_INTENCLR_DRE;
+}
+
 /*	=========================
  *	===== Sercom SPI
  *	=========================
@@ -240,11 +256,11 @@ void SERCOM::enableSPI()
 
 void SERCOM::disableSPI()
 {
-
   while(sercom->SPI.SYNCBUSY.bit.ENABLE)
   {
     //Waiting then enable bit from SYNCBUSY is equal to 0;
   }
+
   //Setting the enable bit to 0
   sercom->SPI.CTRLA.bit.ENABLE = 0;
 }
@@ -360,7 +376,7 @@ void SERCOM::enableWIRE()
 {
   // I2C Master and Slave modes share the ENABLE bit function.
 
-  // Enable the I²C master mode
+  // Enable the I2C master mode
   sercom->I2CM.CTRLA.bit.ENABLE = 1 ;
 
   while ( sercom->I2CM.SYNCBUSY.bit.ENABLE != 0 )
@@ -381,7 +397,7 @@ void SERCOM::disableWIRE()
 {
   // I2C Master and Slave modes share the ENABLE bit function.
 
-  // Enable the I²C master mode
+  // Enable the I2C master mode
   sercom->I2CM.CTRLA.bit.ENABLE = 0 ;
 
   while ( sercom->I2CM.SYNCBUSY.bit.ENABLE != 0 )
@@ -390,17 +406,20 @@ void SERCOM::disableWIRE()
   }
 }
 
-void SERCOM::initSlaveWIRE( uint8_t ucAddress )
+void SERCOM::initSlaveWIRE( uint8_t ucAddress, bool enableGeneralCall )
 {
   // Initialize the peripheral clock and interruption
   initClockNVIC() ;
   resetWIRE() ;
 
   // Set slave mode
-  sercom->I2CS.CTRLA.bit.MODE = I2C_SLAVE_OPERATION ;
+  sercom->I2CS.CTRLA.bit.MODE = I2C_SLAVE_OPERATION;
 
   sercom->I2CS.ADDR.reg = SERCOM_I2CS_ADDR_ADDR( ucAddress & 0x7Ful ) | // 0x7F, select only 7 bits
-                          SERCOM_I2CS_ADDR_ADDRMASK( 0x00ul ) ;         // 0x00, only match exact address
+                          SERCOM_I2CS_ADDR_ADDRMASK( 0x00ul );          // 0x00, only match exact address
+  if (enableGeneralCall) {
+    sercom->I2CS.ADDR.reg |= SERCOM_I2CS_ADDR_GENCEN;                   // enable general call (address 0x00)
+  }
 
   // Set the interrupt register
   sercom->I2CS.INTENSET.reg = SERCOM_I2CS_INTENSET_PREC |   // Stop
@@ -432,7 +451,7 @@ void SERCOM::initMasterWIRE( uint32_t baudrate )
 //  sercom->I2CM.INTENSET.reg = SERCOM_I2CM_INTENSET_MB | SERCOM_I2CM_INTENSET_SB | SERCOM_I2CM_INTENSET_ERROR ;
 
   // Synchronous arithmetic baudrate
-  sercom->I2CM.BAUD.bit.BAUD = SystemCoreClock / ( 2 * baudrate) - 1 ;
+  sercom->I2CM.BAUD.bit.BAUD = SystemCoreClock / ( 2 * baudrate) - 5 - (((SystemCoreClock / 1000000) * WIRE_RISE_TIME_NANOSECONDS) / (2 * 1000));
 }
 
 void SERCOM::prepareNackBitWIRE( void )
@@ -652,16 +671,20 @@ void SERCOM::initClockNVIC( void )
     clockId = GCM_SERCOM3_CORE;
     IdNvic = SERCOM3_IRQn;
   }
+  #if defined(SERCOM4)
   else if(sercom == SERCOM4)
   {
     clockId = GCM_SERCOM4_CORE;
     IdNvic = SERCOM4_IRQn;
   }
+  #endif // SERCOM4
+  #if defined(SERCOM5)
   else if(sercom == SERCOM5)
   {
     clockId = GCM_SERCOM5_CORE;
     IdNvic = SERCOM5_IRQn;
   }
+  #endif // SERCOM5
 
   if ( IdNvic == PendSV_IRQn )
   {
@@ -671,7 +694,7 @@ void SERCOM::initClockNVIC( void )
 
   // Setting NVIC
   NVIC_EnableIRQ(IdNvic);
-  NVIC_SetPriority (IdNvic, (1<<__NVIC_PRIO_BITS) - 1);  /* set Priority */
+  NVIC_SetPriority (IdNvic, SERCOM_NVIC_PRIORITY);  /* set Priority */
 
   //Setting clock
   GCLK->CLKCTRL.reg = GCLK_CLKCTRL_ID( clockId ) | // Generic Clock 0 (SERCOMx)