Merge remote-tracking branch 'upstream/master'

Author: straccio

cores/arduino/avr/pgmspace.h

@@ -1,28 +1,24 @@
-/*
-  pgmspace.h - Definitions for compatibility with AVR pgmspace macros
-
-  Copyright (c) 2015 Arduino LLC
-
-  Based on work of Paul Stoffregen on Teensy 3 (http://pjrc.com)
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE
-*/
+/* Simple compatibility headers for AVR code used with ARM chips
+ * Copyright (c) 2015 Paul Stoffregen <paul@pjrc.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
 
 #ifndef __PGMSPACE_H_
 #define __PGMSPACE_H_ 1
@@ -44,27 +40,91 @@ typedef int16_t prog_int16_t;
 typedef uint16_t prog_uint16_t;
 typedef int32_t prog_int32_t;
 typedef uint32_t prog_uint32_t;
+typedef int64_t prog_int64_t;
+typedef uint64_t prog_uint64_t;
 
+#define memchr_P(str, c, len) memchr((str), (c), (len))
+#define memcmp_P(a, b, n) memcmp((a), (b), (n))
 #define memcpy_P(dest, src, num) memcpy((dest), (src), (num))
-#define strcpy_P(dest, src) strcpy((dest), (src))
+#define memmem_P(a, alen, b, blen) memmem((a), (alen), (b), (blen))
+#define memrchr_P(str, val, len) memrchr((str), (val), (len))
 #define strcat_P(dest, src) strcat((dest), (src))
+#define strchr_P(str, c) strchr((str), (c))
+#define strchrnul_P(str, c) strchrnul((str), (c))
 #define strcmp_P(a, b) strcmp((a), (b))
+#define strcpy_P(dest, src) strcpy((dest), (src))
+#define strcasecmp_P(a, b) strcasecmp((a), (b))
+#define strcasestr_P(a, b) strcasestr((a), (b))
+#define strlcat_P(dest, src, len) strlcat((dest), (src), (len))
+#define strlcpy_P(dest, src, len) strlcpy((dest), (src), (len))
+#define strlen_P(s) strlen((const char *)(s))
+#define strnlen_P(str, len) strnlen((str), (len))
+#define strncmp_P(a, b, n) strncmp((a), (b), (n))
+#define strncasecmp_P(a, b, n) strncasecmp((a), (b), (n))
+#define strncat_P(a, b, n) strncat((a), (b), (n))
+#define strncpy_P(a, b, n) strncpy((a), (b), (n))
+#define strpbrk_P(str, chrs) strpbrk((str), (chrs))
+#define strrchr_P(str, c) strrchr((str), (c))
+#define strsep_P(strp, delim) strsep((strp), (delim))
+#define strspn_P(str, chrs) strspn((str), (chrs))
 #define strstr_P(a, b) strstr((a), (b))
-#define strlen_P(a) strlen((a))
-#define sprintf_P(s, f, ...) sprintf((s), (f), __VA_ARGS__)
+#define sprintf_P(s, ...) sprintf((s), __VA_ARGS__)
+#define vfprintf_P(fp, s, ...) vfprintf((fp), (s), __VA_ARGS__)
+#define printf_P(...) printf(__VA_ARGS__)
+#define snprintf_P(s, n, ...) snprintf((s), (n), __VA_ARGS__)
+#define vsprintf_P(s, ...) vsprintf((s), __VA_ARGS__)
+#define vsnprintf_P(s, n, ...) vsnprintf((s), (n), __VA_ARGS__)
+#define fprintf_P(fp, ...) fprintf((fp), __VA_ARGS__)
+#define strlen_PF(a) strlen((a))
+#define strnlen_PF(src, len) strnlen((src), (len))
+#define memcpy_PF(dest, src, len) memcpy((dest), (src), (len))
+#define strcpy_PF(dest, src) strcpy((dest), (src))
+#define strncpy_PF(dest, src, len) strncpy((dest), (src), (len))
+#define strcat_PF(dest, src) strcat((dest), (src))
+#define strlcat_PF(dest, src, len) strlcat((dest), (src), (len))
+#define strncat_PF(dest, src, len) strncat((dest), (src), (len))
+#define strcmp_PF(s1, s2) strcmp((s1), (s2))
+#define strncmp_PF(s1, s2, n) strncmp((s1), (s2), (n))
+#define strcasecmp_PF(s1, s2) strcasecmp((s1), (s2))
+#define strncasecmp_PF(s1, s2, n) strncasecmp((s1), (s2), (n))
+#define strstr_PF(s1, s2) strstr((s1), (s2))
+#define strlcpy_PF(dest, src, n) strlcpy((dest), (src), (n))
+#define memcmp_PF(s1, s2, n) memcmp((s1), (s2), (n))
+
 
 #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
+#if 0
 #define pgm_read_word(addr) (*(const unsigned short *)(addr))
 #define pgm_read_dword(addr) (*(const unsigned long *)(addr))
 #define pgm_read_float(addr) (*(const float *)(addr))
+#else
+#define pgm_read_word(addr) ({ \
+	typeof(addr) _addr = (addr); \
+	*(const unsigned short *)(_addr); \
+})
+#define pgm_read_dword(addr) ({ \
+	typeof(addr) _addr = (addr); \
+	*(const unsigned long *)(_addr); \
+})
+#define pgm_read_float(addr) ({ \
+	typeof(addr) _addr = (addr); \
+	*(const float *)(_addr); \
+})
+#define pgm_read_ptr(addr) ({ \
+	typeof(addr) _addr = (addr); \
+	*(void * const *)(_addr); \
+})
+#endif
 
 #define pgm_read_byte_near(addr) pgm_read_byte(addr)
 #define pgm_read_word_near(addr) pgm_read_word(addr)
 #define pgm_read_dword_near(addr) pgm_read_dword(addr)
 #define pgm_read_float_near(addr) pgm_read_float(addr)
+#define pgm_read_ptr_near(addr) pgm_read_ptr(addr)
 #define pgm_read_byte_far(addr) pgm_read_byte(addr)
 #define pgm_read_word_far(addr) pgm_read_word(addr)
 #define pgm_read_dword_far(addr) pgm_read_dword(addr)
 #define pgm_read_float_far(addr) pgm_read_float(addr)
+#define pgm_read_ptr_far(addr) pgm_read_ptr(addr)
 
 #endif

cores/arduino/pins_arduino.h

@@ -20,14 +20,6 @@
 
 #include "PeripheralPins.h"
 
-/**
- * Libc porting layers
- */
-#if defined (  __GNUC__  ) /* GCC CS3 */
-#include <syscalls.h> /** RedHat Newlib minimal stub */
-#define WEAK __attribute__ ((weak))
-#endif
-
 // Arduino digital pin alias
 // GPIO port (A to K) * 16 pins: 176
 enum {

cores/arduino/pins_arduino_var.h

@@ -100,6 +100,54 @@ uint32_t pinNametoDigitalPin(PinName p);
                                      (digitalPinFirstOccurence(p) == PIN_SERIAL_TX))
 #endif
 
+// Default Definitions, could be redefined in variant.h
+#ifndef ADC_RESOLUTION
+#define ADC_RESOLUTION              12
+#endif
+#ifndef DACC_RESOLUTION
+#define DACC_RESOLUTION             12
+#endif
+#ifndef PWM_RESOLUTION
+#define PWM_RESOLUTION              8
+#endif
+#ifndef PWM_FREQUENCY
+#define PWM_FREQUENCY               1000
+#endif
+#ifndef PWM_MAX_DUTY_CYCLE
+#define PWM_MAX_DUTY_CYCLE          255
+#endif
+
+// Default for Arduino connector compatibility
+// SPI Definitions
+#ifndef SS
+#define SS                          10
+#endif
+#ifndef SS1
+#define SS1                         4
+#endif
+#ifndef SS2
+#define SS2                         7
+#endif
+#ifndef SS3
+#define SS3                         8
+#endif
+#ifndef MOSI
+#define MOSI                        11
+#endif
+#ifndef MISO
+#define MISO                        12
+#endif
+#ifndef SCK
+#define SCK                         13
+#endif
+// I2C Definitions
+#ifndef SDA
+#define SDA                         14
+#endif
+#ifndef SCL
+#define SCL                         15
+#endif
+
 #ifdef __cplusplus
 }
 #endif

cores/arduino/stm32/interrupt.h

@@ -43,6 +43,10 @@
 #include "stm32_def.h"
 #include "PinNames.h"
 
+#if defined(STM32F3xx)
+#define EXTI2_IRQn    EXTI2_TSC_IRQn
+#endif
+
 #ifdef __cplusplus
 #include <functional>
 

cores/arduino/stm32/stm32_def.c

@@ -0,0 +1,23 @@
+#include "stm32_def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+  * @brief  This function is executed in case of error occurrence.
+  * @param  None
+  * @retval None
+  */
+WEAK void _Error_Handler(const char * msg, int val)
+{
+  /* User can add his own implementation to report the HAL error return state */
+  printf("Error: %s (%i)\n", msg, val);
+  while(1)
+  {
+  }
+}
+
+#ifdef __cplusplus
+}
+#endif

cores/arduino/stm32/stm32_def.h

@@ -51,34 +51,29 @@
 #endif
 
 // Here define some compatibility
-#ifdef STM32F0xx
-
-#elif defined(STM32F1xx)
-
-#elif defined(STM32F2xx)
-
-#elif defined(STM32F3xx)
-#define EXTI2_IRQn                       EXTI2_TSC_IRQn
-#elif defined(STM32F4xx)
-
-#elif defined(STM32F7xx)
-
-#elif defined(STM32L0xx)
-
-#elif defined(STM32L1xx)
-
-#elif defined(STM32L4xx)
-#endif
-
 #ifndef CAN1
 #define CAN1 CAN
 #endif
 
+/**
+ * Libc porting layers
+ */
+#if defined (  __GNUC__  ) /* GCC CS3 */
+#include <syscalls.h> /** RedHat Newlib minimal stub */
+#define WEAK __attribute__ ((weak))
+#endif
+
 #ifdef __cplusplus
 extern "C"{
 #endif // __cplusplus
+
 // weaked functions declaration
 void SystemClock_Config(void);
+
+void _Error_Handler(const char *, int);
+
+#define Error_Handler() _Error_Handler(__FILE__, __LINE__)
+
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus

libraries/SPI/README.md

@@ -0,0 +1,70 @@
+## SPI
+
+STM32 SPI library has been modified with the possibility to manage several CS pins without to stop the SPI interface.  
+_We do not describe here the [SPI Arduino API](https://www.arduino.cc/en/Reference/SPI) but the functionalities added._  
+
+We give to the user 3 possiblities about the management of the CS pin:  
+1. the CS pin is managed directly by the user code before to transfer the data (like the Arduino SPI library)  
+2. the user gives the CS pin number to the library API and the library manages itself the CS pin (see example below)  
+3. the user uses a hardware CS pin linked to the SPI peripheral  
+
+### New API functions
+
+* **`SPIClass::SPIClass(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t ssel)`**: alternative class constructor  
+_Params_ SPI mosi pin  
+_Params_ SPI miso pin  
+_Params_ SPI sclk pin  
+_Params_ (optional) SPI ssel pin. This pin must be an hardware CS pin. If you configure this pin, the chip select will be managed by the SPI peripheral. Do not use API functions with CS pin in parameter.  
+
+* **`void SPIClass::begin(uint8_t _pin)`**: initialize the SPI interface and add a CS pin  
+_Params_ spi CS pin to be managed by the SPI library  
+
+* **`void beginTransaction(uint8_t pin, SPISettings settings)`**: allows to configure the SPI with other parameter. These new parameter are saved this an associated CS pin.  
+_Params_ SPI CS pin to be managed by the SPI library  
+_Params_ SPI settings  
+
+* **`void endTransaction(uint8_t pin)`**: removes a CS pin and the SPI settings associated  
+_Params_ SPI CS pin managed by the SPI library  
+
+**_Note 1_** The following functions must be called after initialization of the SPI instance with `begin()` or `beginTransaction()`.  
+If you have several device to manage, you can call `beginTransaction()` several time with different CS pin in parameter.  
+Then you can call the following functions with different CS pin without call again `beginTransaction()` (until you call `end()` or `endTransaction()`).  
+
+**_Note 2_** If the mode is set to `SPI_CONTINUE`, the CS pin is kept enabled. Be careful in case you use several CS pin.  
+
+* **`byte transfer(uint8_t pin, uint8_t _data, SPITransferMode _mode = SPI_LAST)`**: write/read one byte  
+_Params_ SPI CS pin managed by the SPI library  
+_Params_ data to write  
+_Params_ (optional) if `SPI_LAST` CS pin is reset, `SPI_CONTINUE` the CS pin is kept enabled.  
+_Return_ byte received  
+
+* **`uint16_t transfer16(uint8_t pin, uint16_t _data, SPITransferMode _mode = SPI_LAST)`**: write/read half-word  
+_Params_ SPI CS pin managed by the SPI library  
+_Params_ 16bits data to write  
+_Params_ (optional) if `SPI_LAST` CS pin is reset, `SPI_CONTINUE` the CS pin is kept enabled.  
+_Return_ 16bits data received  
+
+* **`void transfer(uint8_t pin, void *_buf, size_t _count, SPITransferMode _mode = SPI_LAST)`**: write/read several bytes. Only one buffer used to write and read the data  
+_Params_ SPI CS pin managed by the SPI library  
+_Params_ pointer to data to write. The data will be replaced by the data read.  
+_Params_ number of data to write/read.
+_Params_ (optional) if `SPI_LAST` CS pin is reset, `SPI_CONTINUE` the CS pin is kept enabled.  
+
+* **`void transfer(byte _pin, void *_bufout, void *_bufin, size_t _count, SPITransferMode _mode = SPI_LAST)`**: write/read several bytes. One buffer for the output data and one for the input data  
+_Params_ SPI CS pin managed by the SPI library  
+_Params_ pointer to data to write.  
+_Params_ pointer where to store the data read.  
+_Params_ number of data to write/read.  
+_Params_ (optional) if `SPI_LAST` CS pin is reset, `SPI_CONTINUE` the CS pin is kept enabled.  
+
+### Example
+
+This is an example of the use of the CS pin management:  
+
+```C++
+SPI.begin(2); //Enables the SPI instance with default settings and attachs the CS pin  
+SPI.beginTransaction(1, settings); //Attachs another CS pin and configure the SPI instance with other settings  
+SPI.transfer(1, 0x52); //Transfers data to the first device
+SPI.transfer(2, 0xA4); //Transfers data to the second device. The SPI instance is configured with the right settings  
+SPI.end() //SPI instance is disabled
+```