Update Temperature board driver to be AVR32 compatible when the ADC peripheral driver...

Add SPI driver aliases for the old function names in the AVR8 driver, so that existing code will still compile against the new version.

diff --git a/LUFA/Common/Common.h b/LUFA/Common/Common.h
index 67bbb92..74b687b 100644 (file)
--- a/LUFA/Common/Common.h
+++ b/LUFA/Common/Common.h
@@ -63,7 +63,7 @@
                        #include "Atomic.h"\r
 \r
                        #define PROGMEM const\r
                        #include "Atomic.h"\r
 \r
                        #define PROGMEM const\r

-               #else\r
+               #elif defined(__AVR__)\r

                        #include <avr/io.h>\r
                #endif\r
 \r
                        #include <avr/io.h>\r
                #endif\r
 \r


@@ -195,7 +195,7 @@
 \r
                                /** Type define for a signed native word-sized chunk of data. */\r
                                typedef int32_t intN_t;\r
 \r
                                /** Type define for a signed native word-sized chunk of data. */\r
                                typedef int32_t intN_t;\r

-                       #else\r
+                       #elif defined(__AVR__)\r

                                /** Type define for an unsigned native word-sized chunk of data. */\r
                                typedef uint8_t uintN_t;\r
 \r
                                /** Type define for an unsigned native word-sized chunk of data. */\r
                                typedef uint8_t uintN_t;\r
 \r

diff --git a/LUFA/Drivers/Board/Dataflash.h b/LUFA/Drivers/Board/Dataflash.h
index c0f314a..dfd8cd6 100644 (file)
--- a/LUFA/Drivers/Board/Dataflash.h
+++ b/LUFA/Drivers/Board/Dataflash.h
@@ -127,7 +127,7 @@
                        static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)\r
                        {\r
                        static inline uint8_t Dataflash_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline uint8_t Dataflash_TransferByte(const uint8_t Byte)\r
                        {\r

-                               return SPI_TransferByte(Byte);\r
+                               return SPI_Transfer(Byte);\r

                        }\r
 \r
                        /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.\r
                        }\r
 \r
                        /** Sends a byte to the currently selected dataflash IC, and ignores the next byte from the dataflash.\r


@@ -137,7 +137,7 @@
                        static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Dataflash_SendByte(const uint8_t Byte)\r
                        {\r
                        static inline void Dataflash_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
                        static inline void Dataflash_SendByte(const uint8_t Byte)\r
                        {\r

-                               SPI_SendByte(Byte);\r
+                               SPI_Send(Byte);\r

                        }\r
                        \r
                        /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.\r
                        }\r
                        \r
                        /** Sends a dummy byte to the currently selected dataflash IC, and returns the next byte from the dataflash.\r


@@ -147,7 +147,7 @@
                        static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
                        static inline uint8_t Dataflash_ReceiveByte(void)\r
                        {\r
                        static inline uint8_t Dataflash_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
                        static inline uint8_t Dataflash_ReceiveByte(void)\r
                        {\r

-                               return SPI_ReceiveByte();\r
+                               return SPI_Receive();\r

                        }\r
 \r
                /* Includes: */\r
                        }\r
 \r
                /* Includes: */\r

diff --git a/LUFA/Drivers/Board/Temperature.c b/LUFA/Drivers/Board/Temperature.c
index ea12bf7..09d7050 100644 (file)
--- a/LUFA/Drivers/Board/Temperature.c
+++ b/LUFA/Drivers/Board/Temperature.c
@@ -47,14 +47,25 @@ int8_t Temperature_GetTemperature(void)
 {\r
        uint16_t Temp_ADC = ADC_GetChannelReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | TEMP_ADC_CHANNEL_MASK);\r
 \r
 {\r
        uint16_t Temp_ADC = ADC_GetChannelReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | TEMP_ADC_CHANNEL_MASK);\r
 \r

+       #if defined(__AVR32__)\r
+       if (Temp_ADC > Temperature_Lookup[0])\r
+         return TEMP_MIN_TEMP; \r
+\r
+       for (uint16_t Index = 0; Index < TEMP_TABLE_SIZE; Index++)\r
+       {\r
+               if (Temp_ADC > Temperature_Lookup[Index])\r
+                 return (Index + TEMP_TABLE_OFFSET);\r
+       }\r
+       #elif defined(__AVR__)\r

        if (Temp_ADC > pgm_read_word(&Temperature_Lookup[0]))\r
        if (Temp_ADC > pgm_read_word(&Temperature_Lookup[0]))\r

-         return TEMP_MIN_TEMP;\r
+         return TEMP_MIN_TEMP; \r

 \r
        for (uint16_t Index = 0; Index < TEMP_TABLE_SIZE; Index++)\r
        {\r
                if (Temp_ADC > pgm_read_word(&Temperature_Lookup[Index]))\r
                  return (Index + TEMP_TABLE_OFFSET);\r
        }\r
 \r
        for (uint16_t Index = 0; Index < TEMP_TABLE_SIZE; Index++)\r
        {\r
                if (Temp_ADC > pgm_read_word(&Temperature_Lookup[Index]))\r
                  return (Index + TEMP_TABLE_OFFSET);\r
        }\r

+       #endif\r

 \r
        return TEMP_MAX_TEMP;\r
 }\r
 \r
        return TEMP_MAX_TEMP;\r
 }\r

diff --git a/LUFA/Drivers/Board/Temperature.h b/LUFA/Drivers/Board/Temperature.h
index 12e6df1..8700839 100644 (file)
--- a/LUFA/Drivers/Board/Temperature.h
+++ b/LUFA/Drivers/Board/Temperature.h
@@ -54,8 +54,10 @@
 \r
        /* Includes: */\r
                #if defined(__AVR32__)\r
 \r
        /* Includes: */\r
                #if defined(__AVR32__)\r

+                       #include <avr32/io.h>\r

                        #include <stdint.h>\r
                        #include <stdint.h>\r

-               #else\r
+               #elif defined(__AVR__)\r
+                       #include <avr/io.h>\r

                        #include <avr/pgmspace.h>\r
                #endif\r
 \r
                        #include <avr/pgmspace.h>\r
                #endif\r
 \r

diff --git a/LUFA/Drivers/Peripheral/ADC.h b/LUFA/Drivers/Peripheral/ADC.h
index ef708b4..533f4d2 100644 (file)
--- a/LUFA/Drivers/Peripheral/ADC.h
+++ b/LUFA/Drivers/Peripheral/ADC.h
@@ -58,6 +58,8 @@
        #endif\r
 \r
        /* Includes: */\r
        #endif\r
 \r
        /* Includes: */\r

+               #include "../../Common/Common.h"                \r
+\r

                #if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || \\r
                     defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB647__) || \\r
                         defined(__AVR_ATmega16U4__)  || defined(__AVR_ATmega32U4__) || \\r
                #if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || \\r
                     defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB647__) || \\r
                         defined(__AVR_ATmega16U4__)  || defined(__AVR_ATmega32U4__) || \\r

diff --git a/LUFA/Drivers/Peripheral/AVR32/SPI.h b/LUFA/Drivers/Peripheral/AVR32/SPI.h
index b748479..4322eaa 100644 (file)
--- a/LUFA/Drivers/Peripheral/AVR32/SPI.h
+++ b/LUFA/Drivers/Peripheral/AVR32/SPI.h
@@ -82,58 +82,69 @@
                        /** Initialises the SPI subsystem, ready for transfers. Must be called before calling any other\r
                         *  SPI routines.\r
                         *\r
                        /** Initialises the SPI subsystem, ready for transfers. Must be called before calling any other\r
                         *  SPI routines.\r
                         *\r

+                        *  \note The individual AVR32 chip select control registers are left at their defaults; it is up to the user\r
+                        *        to configure these seperately once the SPI module has been initialized.\r
+                        *\r
+                        *  \note The physical GPIO pins for the AVR32's SPI are not altered; it is up to the user to\r
+                        *        configure these seperately to connect the SPI module to the desired GPIO pins via the\r
+                        *        GPIO MUX registers.\r
+                        *\r

                         *  \param[in] SPIOptions  SPI Options, a mask consisting of one of each of the SPI_SPEED_*\r
                         *                         and SPI_MODE_* masks\r
                         */\r
                         *  \param[in] SPIOptions  SPI Options, a mask consisting of one of each of the SPI_SPEED_*\r
                         *                         and SPI_MODE_* masks\r
                         */\r

-                       static inline void SPI_Init(const uint8_t SPIOptions)\r
+                       static inline void SPI_Init(const uintN_t SPIOptions)\r

                        {\r
                        {\r

-                               AVR32_SPI.cr = AVR32_SPI_CR_SPIEN_MASK | AVR32_SPI_CR_SWRST_MASK;\r
+                               AVR32_SPI.cr = (AVR32_SPI_CR_SPIEN_MASK | AVR32_SPI_CR_SWRST_MASK);\r

                                AVR32_SPI.mr = SPIOptions;\r
                        }\r
                                AVR32_SPI.mr = SPIOptions;\r
                        }\r

-                       \r
+\r

                        /** Turns off the SPI driver, disabling and returning used hardware to their default configuration. */\r
                        static inline void SPI_ShutDown(void)\r
                        {\r
                                AVR32_SPI.cr = AVR32_SPI_CR_SPIDIS_MASK;\r
                        }\r
                        \r
                        /** Turns off the SPI driver, disabling and returning used hardware to their default configuration. */\r
                        static inline void SPI_ShutDown(void)\r
                        {\r
                                AVR32_SPI.cr = AVR32_SPI_CR_SPIDIS_MASK;\r
                        }\r
                        \r

-                       /** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.\r
+                       /** Sends and receives a transfer through the SPI interface, blocking until the transfer is complete.\r
+                        *  The width of the data that is transferred is dependant on the settings of the currently selected\r
+                        *  peripheral.\r

                         *\r
                         *\r

-                        *  \param[in] Byte  Byte to send through the SPI interface\r
+                        *  \param[in] Data  Data to send through the SPI interface\r

                         *\r
                         *\r

-                        *  \return Response byte from the attached SPI device\r
+                        *  \return Response data from the attached SPI device\r

                         */\r
                         */\r

-                       static inline uint8_t SPI_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
-                       static inline uint8_t SPI_TransferByte(const uint8_t Byte)\r
+                       static inline uint16_t SPI_Transfer(const uint16_t Data) ATTR_ALWAYS_INLINE;\r
+                       static inline uint16_t SPI_Transfer(const uint16_t Data)\r

                        {\r
                        {\r

-                               AVR32_SPI.tdr = Byte;\r
-                               // TODO: Wait for receive\r
+                               AVR32_SPI.TDR.td = Data;\r
+                               while (!(AVR32_SPI.SR.tdre));\r

                                return AVR32_SPI.rdr;\r
                        }\r
 \r
                                return AVR32_SPI.rdr;\r
                        }\r
 \r

-                       /** Sends a byte through the SPI interface, blocking until the transfer is complete. The response\r
-                        *  byte sent to from the attached SPI device is ignored.\r
+                       /** Sends a transfer through the SPI interface, blocking until the transfer is complete. The response\r
+                        *  data sent to from the attached SPI device is ignored. The width of the data that is transferred is\r
+                        *  dependant on the settings of the currently selected peripheral.\r

                         *\r
                         *\r

-                        *  \param[in] Byte Byte to send through the SPI interface\r
+                        *  \param[in] Data  Data to send through the SPI interface\r

                         */\r
                         */\r

-                       static inline void SPI_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
-                       static inline void SPI_SendByte(const uint8_t Byte)\r
+                       static inline void SPI_Send(const uint16_t Data) ATTR_ALWAYS_INLINE;\r
+                       static inline void SPI_Send(const uint16_t Data)\r

                        {\r
                        {\r

-                               AVR32_SPI.tdr = Byte;\r
-                               // TODO: Wait for receive                               \r
+                               AVR32_SPI.TDR.td = Data;\r
+                               while (!(AVR32_SPI.SR.tdre));\r

                        }\r
 \r
                        }\r
 \r

-                       /** Sends a dummy byte through the SPI interface, blocking until the transfer is complete. The response\r
-                        *  byte from the attached SPI device is returned.\r
+                       /** Sends a dummy transfer through the SPI interface, blocking until the transfer is complete. The response\r
+                        *  data from the attached SPI device is returned. The width of the data that is transferred is dependant on\r
+                        *  the settings of the currently selected peripheral.\r

                         *\r
                         *\r

-                        *  \return The response byte from the attached SPI device\r
+                        *  \return The response data from the attached SPI device\r

                         */\r
                         */\r

-                       static inline uint8_t SPI_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
-                       static inline uint8_t SPI_ReceiveByte(void)\r
+                       static inline uint16_t SPI_Receive(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
+                       static inline uint16_t SPI_Receive(void)\r

                        {\r
                        {\r

-                               AVR32_SPI.tdr = 0x00;\r
-                               // TODO: Wait for receive                               \r
-                               return AVR32_SPI.rdr;\r
+                               AVR32_SPI.TDR.td = 0x0000;\r
+                               while (!(AVR32_SPI.SR.tdre));\r
+                               return AVR32_SPI.RDR.rd;\r

                        }\r
 \r
        /* Disable C linkage for C++ Compilers: */\r
                        }\r
 \r
        /* Disable C linkage for C++ Compilers: */\r

diff --git a/LUFA/Drivers/Peripheral/AVR8/ADC.h b/LUFA/Drivers/Peripheral/AVR8/ADC.h
index 06f9d3b..eac7f9f 100644 (file)
--- a/LUFA/Drivers/Peripheral/AVR8/ADC.h
+++ b/LUFA/Drivers/Peripheral/AVR8/ADC.h
@@ -51,8 +51,6 @@
 #define __ADC_AVR8_H__\r
 \r
        /* Includes: */\r
 #define __ADC_AVR8_H__\r
 \r
        /* Includes: */\r

-               #include "../../../Common/Common.h"\r
-               \r

                #include <avr/io.h>\r
                #include <stdbool.h>\r
                \r
                #include <avr/io.h>\r
                #include <stdbool.h>\r
                \r

diff --git a/LUFA/Drivers/Peripheral/AVR8/SPI.h b/LUFA/Drivers/Peripheral/AVR8/SPI.h
index f466162..42ff8e7 100644 (file)
--- a/LUFA/Drivers/Peripheral/AVR8/SPI.h
+++ b/LUFA/Drivers/Peripheral/AVR8/SPI.h
@@ -118,7 +118,7 @@
                         *  \param[in] SPIOptions  SPI Options, a mask consisting of one of each of the SPI_SPEED_*,\r
                         *                         SPI_SCK_*, SPI_SAMPLE_* and SPI_MODE_* masks\r
                         */\r
                         *  \param[in] SPIOptions  SPI Options, a mask consisting of one of each of the SPI_SPEED_*,\r
                         *                         SPI_SCK_*, SPI_SAMPLE_* and SPI_MODE_* masks\r
                         */\r

-                       static inline void SPI_Init(const uint8_t SPIOptions)\r
+                       static inline void SPI_Init(const uintN_t SPIOptions)\r

                        {\r
                                DDRB  |= ((1 << 1) | (1 << 2));\r
                                PORTB |= ((1 << 0) | (1 << 3));\r
                        {\r
                                DDRB  |= ((1 << 1) | (1 << 2));\r
                                PORTB |= ((1 << 0) | (1 << 3));\r


@@ -143,14 +143,14 @@
                        \r
                        /** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.\r
                         *\r
                        \r
                        /** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.\r
                         *\r

-                        *  \param[in] Byte  Byte to send through the SPI interface\r
+                        *  \param[in] Data  Byte to send through the SPI interface\r

                         *\r
                         *  \return Response byte from the attached SPI device\r
                         */\r
                         *\r
                         *  \return Response byte from the attached SPI device\r
                         */\r

-                       static inline uint8_t SPI_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
-                       static inline uint8_t SPI_TransferByte(const uint8_t Byte)\r
+                       static inline uint8_t SPI_Transfer(const uint8_t Data) ATTR_ALWAYS_INLINE;\r
+                       static inline uint8_t SPI_Transfer(const uint8_t Data)\r

                        {\r
                        {\r

-                               SPDR = Byte;\r
+                               SPDR = Data;\r

                                while (!(SPSR & (1 << SPIF)));\r
                                return SPDR;\r
                        }\r
                                while (!(SPSR & (1 << SPIF)));\r
                                return SPDR;\r
                        }\r


@@ -158,12 +158,12 @@
                        /** Sends a byte through the SPI interface, blocking until the transfer is complete. The response\r
                         *  byte sent to from the attached SPI device is ignored.\r
                         *\r
                        /** Sends a byte through the SPI interface, blocking until the transfer is complete. The response\r
                         *  byte sent to from the attached SPI device is ignored.\r
                         *\r

-                        *  \param[in] Byte Byte to send through the SPI interface\r
+                        *  \param[in] Data  Byte to send through the SPI interface\r

                         */\r
                         */\r

-                       static inline void SPI_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;\r
-                       static inline void SPI_SendByte(const uint8_t Byte)\r
+                       static inline void SPI_Send(const uint8_t Data) ATTR_ALWAYS_INLINE;\r
+                       static inline void SPI_Send(const uint8_t Data)\r

                        {\r
                        {\r

-                               SPDR = Byte;\r
+                               SPDR = Data;\r

                                while (!(SPSR & (1 << SPIF)));\r
                        }\r
 \r
                                while (!(SPSR & (1 << SPIF)));\r
                        }\r
 \r


@@ -172,13 +172,28 @@
                         *\r
                         *  \return The response byte from the attached SPI device\r
                         */\r
                         *\r
                         *  \return The response byte from the attached SPI device\r
                         */\r

-                       static inline uint8_t SPI_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
-                       static inline uint8_t SPI_ReceiveByte(void)\r
+                       static inline uint8_t SPI_Receive(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;\r
+                       static inline uint8_t SPI_Receive(void)\r

                        {\r
                                SPDR = 0x00;\r
                                while (!(SPSR & (1 << SPIF)));\r
                                return SPDR;\r
                        }\r
                        {\r
                                SPDR = 0x00;\r
                                while (!(SPSR & (1 << SPIF)));\r
                                return SPDR;\r
                        }\r

+       \r
+                       #if defined(__DOXYGEN__)\r
+                               /** Alias for \ref SPI_Transfer(), for compatibility with legacy LUFA applications. */\r
+                               static inline uint8_t SPI_TransferByte(const uint8_t Byte) ATTR_DEPRECATED;\r
+\r
+                               /** Alias for \ref SPI_Send(), for compatibility with legacy LUFA applications. */\r
+                               static inline void SPI_SendByte(const uint8_t Byte) ATTR_DEPRECATED;\r
+\r
+                               /** Alias for \ref SPI_Receive(), for compatibility with legacy LUFA applications. */\r
+                               static inline uint8_t SPI_ReceiveByte(void) ATTR_DEPRECATED;\r
+                       #else\r
+                               #define SPI_TransferByte(x)      SPI_Transfer(x)\r
+                               #define SPI_SendByte(x)          SPI_Send(x)\r
+                               #define SPI_ReceiveByte()        SPI_Receive()\r
+                       #endif\r

 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
 \r
        /* Disable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r

diff --git a/LUFA/Drivers/Peripheral/AVR8/TWI.h b/LUFA/Drivers/Peripheral/AVR8/TWI.h
index d169b82..43f70d9 100644 (file)
--- a/LUFA/Drivers/Peripheral/AVR8/TWI.h
+++ b/LUFA/Drivers/Peripheral/AVR8/TWI.h
@@ -51,8 +51,6 @@
 #define __TWI_AVR8_H__\r
 \r
        /* Includes: */\r
 #define __TWI_AVR8_H__\r
 \r
        /* Includes: */\r

-               #include "../../../Common/Common.h"\r
-               \r

                #include <avr/io.h>\r
                #include <stdbool.h>\r
                #include <util/twi.h>\r
                #include <avr/io.h>\r
                #include <stdbool.h>\r
                #include <util/twi.h>\r

diff --git a/LUFA/Drivers/Peripheral/SPI.h b/LUFA/Drivers/Peripheral/SPI.h
index aac3d95..6c4ac28 100644 (file)
--- a/LUFA/Drivers/Peripheral/SPI.h
+++ b/LUFA/Drivers/Peripheral/SPI.h
@@ -59,9 +59,11 @@
        #endif\r
 \r
        /* Includes: */\r
        #endif\r
 \r
        /* Includes: */\r

+               #include "../../Common/Common.h"                \r
+\r

                #if defined(__AVR32__)\r
                        #include "AVR32/SPI.h"\r
                #if defined(__AVR32__)\r
                        #include "AVR32/SPI.h"\r

-               #else\r
+               #elif defined(__AVR__)\r

                        #include "AVR8/SPI.h"           \r
                #endif\r
                \r
                        #include "AVR8/SPI.h"           \r
                #endif\r
                \r

diff --git a/LUFA/Drivers/Peripheral/Serial.h b/LUFA/Drivers/Peripheral/Serial.h
index a2e06fa..838c1fd 100644 (file)
--- a/LUFA/Drivers/Peripheral/Serial.h
+++ b/LUFA/Drivers/Peripheral/Serial.h
@@ -60,15 +60,15 @@
        #endif\r
 \r
        /* Includes: */\r
        #endif\r
 \r
        /* Includes: */\r

+               #include "../../Common/Common.h"                \r
+               #include "../Misc/TerminalCodes.h"\r
+\r

                #if defined(__AVR32__)\r
                        #include "AVR32/Serial.h"\r
                #if defined(__AVR32__)\r
                        #include "AVR32/Serial.h"\r

-               #else\r
+               #elif defined(__AVR__)\r

                        #include "AVR8/Serial.h"                \r
                #endif\r
                \r
                        #include "AVR8/Serial.h"                \r
                #endif\r
                \r

-               #include "../../Common/Common.h"\r
-               #include "../Misc/TerminalCodes.h"\r
-\r

        /* Enable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
                        extern "C" {\r
        /* Enable C linkage for C++ Compilers: */\r
                #if defined(__cplusplus)\r
                        extern "C" {\r

diff --git a/LUFA/Drivers/Peripheral/SerialStream.h b/LUFA/Drivers/Peripheral/SerialStream.h
index feadd0a..e22dc42 100644 (file)
--- a/LUFA/Drivers/Peripheral/SerialStream.h
+++ b/LUFA/Drivers/Peripheral/SerialStream.h
@@ -57,6 +57,8 @@
                #include <avr/io.h>\r
                #include <stdio.h>\r
                \r
                #include <avr/io.h>\r
                #include <stdio.h>\r
                \r

+               #include "../../Common/Common.h"                \r
+\r

                #include "Serial.h"\r
        \r
        /* Enable C linkage for C++ Compilers: */\r
                #include "Serial.h"\r
        \r
        /* Enable C linkage for C++ Compilers: */\r

diff --git a/LUFA/Drivers/Peripheral/TWI.h b/LUFA/Drivers/Peripheral/TWI.h
index fbb95e4..a3d4087 100644 (file)
--- a/LUFA/Drivers/Peripheral/TWI.h
+++ b/LUFA/Drivers/Peripheral/TWI.h
@@ -57,6 +57,8 @@
        #endif\r
 \r
        /* Includes: */\r
        #endif\r
 \r
        /* Includes: */\r

+               #include "../../Common/Common.h"                \r
+\r

                #if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || \\r
                     defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB647__) || \\r
                         defined(__AVR_ATmega16U4__)  || defined(__AVR_ATmega32U4__) || \\r
                #if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || \\r
                     defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB647__) || \\r
                         defined(__AVR_ATmega16U4__)  || defined(__AVR_ATmega32U4__) || \\r

diff --git a/LUFA/ManPages/FutureChanges.txt b/LUFA/ManPages/FutureChanges.txt
index d3e3428..53c074b 100644 (file)
--- a/LUFA/ManPages/FutureChanges.txt
+++ b/LUFA/ManPages/FutureChanges.txt
@@ -41,13 +41,14 @@
   *    - Joystick Board Driver\r
   *    - Buttons Board Driver\r
   *    - LEDs Board Driver\r
   *    - Joystick Board Driver\r
   *    - Buttons Board Driver\r
   *    - LEDs Board Driver\r

+  *    - Simple Scheduler\r
+  *    - Temperature Board Driver\r

   *\r
   *  The following drivers have been partially ported:\r
   *    - SPI Peripheral Driver\r
   *\r
   *  The following drivers have not yet been ported:\r
   *    - Dataflash Board Driver\r
   *\r
   *  The following drivers have been partially ported:\r
   *    - SPI Peripheral Driver\r
   *\r
   *  The following drivers have not yet been ported:\r
   *    - Dataflash Board Driver\r

-  *    - Temperature Board Driver\r

   *    - Serial Peripheral Driver\r
   *    - ADC Peripheral Driver\r
   *    - TWI Peripheral Driver\r
   *    - Serial Peripheral Driver\r
   *    - ADC Peripheral Driver\r
   *    - TWI Peripheral Driver\r

diff --git a/LUFA/ManPages/MigrationInformation.txt b/LUFA/ManPages/MigrationInformation.txt
index 2623640..206fd45 100644 (file)
--- a/LUFA/ManPages/MigrationInformation.txt
+++ b/LUFA/ManPages/MigrationInformation.txt
@@ -13,7 +13,9 @@
  * \section Sec_MigrationXXXXXX Migrating from 100219 to XXXXXX\r
  *\r
  * \section Sec_Migration100219 Migrating from 091223 to 100219\r
  * \section Sec_MigrationXXXXXX Migrating from 100219 to XXXXXX\r
  *\r
  * \section Sec_Migration100219 Migrating from 091223 to 100219\r

- *    - (None)\r
+ *  <b>Non-USB Library Components</b>\r
+ *    - The "Byte" suffix on the SPI peripheral driver's send and receive routines has been dropped, to make the interface consistant\r
+ *      between the AVR8 driver and the new AVR32 driver, which supports variable width transfers.\r

  *\r
  *  <b>Non-USB Library Components</b>\r
  *    - Due to some ADC channels not being identical to their ADC MUX selection masks for single-ended conversions on some AVR models,\r
  *\r
  *  <b>Non-USB Library Components</b>\r
  *    - Due to some ADC channels not being identical to their ADC MUX selection masks for single-ended conversions on some AVR models,\r

diff --git a/LUFA/Scheduler/Scheduler.h b/LUFA/Scheduler/Scheduler.h
index 084fb1e..1ed6491 100644 (file)
--- a/LUFA/Scheduler/Scheduler.h
+++ b/LUFA/Scheduler/Scheduler.h
@@ -61,7 +61,7 @@
  *      {\r
  *             { .Task = MyTask1, .TaskStatus = TASK_RUN, .GroupID = 1  },\r
  *             { .Task = MyTask2, .TaskStatus = TASK_RUN, .GroupID = 1  },\r
  *      {\r
  *             { .Task = MyTask1, .TaskStatus = TASK_RUN, .GroupID = 1  },\r
  *             { .Task = MyTask2, .TaskStatus = TASK_RUN, .GroupID = 1  },\r

- *      }\r
+ *      };\r

  *\r
  *      int main(void)\r
  *      {\r
  *\r
  *      int main(void)\r
  *      {\r


@@ -89,7 +89,7 @@
        #if defined(__AVR32__)\r
                #include <avr32/io.h>\r
                #include <stdbool.h>\r
        #if defined(__AVR32__)\r
                #include <avr32/io.h>\r
                #include <stdbool.h>\r

-       #else\r
+       #elif defined(__AVR__)\r

                #include <avr/io.h>\r
                #include <util/atomic.h>\r
                #include <stdbool.h>\r
                #include <avr/io.h>\r
                #include <util/atomic.h>\r
                #include <stdbool.h>\r

diff --git a/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c b/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
index 85b31fb..9922c19 100644 (file)
--- a/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
+++ b/Projects/AVRISP-MKII/Lib/ISP/ISPProtocol.c
@@ -85,7 +85,7 @@ void ISPProtocol_EnterISPMode(void)
                for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)\r
                {\r
                        ISPProtocol_DelayMS(Enter_ISP_Params.ByteDelay);\r
                for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)\r
                {\r
                        ISPProtocol_DelayMS(Enter_ISP_Params.ByteDelay);\r

-                       ResponseBytes[RByte] = SPI_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);\r
+                       ResponseBytes[RByte] = SPI_Transfer(Enter_ISP_Params.EnterProgBytes[RByte]);\r

                }\r
                \r
                /* Check if polling disabled, or if the polled value matches the expected value */\r
                }\r
                \r
                /* Check if polling disabled, or if the polled value matches the expected value */\r


@@ -204,10 +204,10 @@ void ISPProtocol_ProgramMemory(uint8_t V2Command)
                        bool    IsOddByte   = (CurrentByte & 0x01);\r
                        uint8_t ByteToWrite = *(NextWriteByte++);\r
                \r
                        bool    IsOddByte   = (CurrentByte & 0x01);\r
                        uint8_t ByteToWrite = *(NextWriteByte++);\r
                \r

-                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);\r
-                       SPI_SendByte(CurrentAddress >> 8);\r
-                       SPI_SendByte(CurrentAddress & 0xFF);\r
-                       SPI_SendByte(ByteToWrite);\r
+                       SPI_Send(Write_Memory_Params.ProgrammingCommands[0]);\r
+                       SPI_Send(CurrentAddress >> 8);\r
+                       SPI_Send(CurrentAddress & 0xFF);\r
+                       SPI_Send(ByteToWrite);\r

                        \r
                        /* AVR FLASH addressing requires us to modify the write command based on if we are writing a high\r
                         * or low byte at the current word address */\r
                        \r
                        /* AVR FLASH addressing requires us to modify the write command based on if we are writing a high\r
                         * or low byte at the current word address */\r


@@ -230,10 +230,10 @@ void ISPProtocol_ProgramMemory(uint8_t V2Command)
                /* If the current page must be committed, send the PROGRAM PAGE command to the target */\r
                if (Write_Memory_Params.ProgrammingMode & PROG_MODE_COMMIT_PAGE_MASK)\r
                {\r
                /* If the current page must be committed, send the PROGRAM PAGE command to the target */\r
                if (Write_Memory_Params.ProgrammingMode & PROG_MODE_COMMIT_PAGE_MASK)\r
                {\r

-                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[1]);\r
-                       SPI_SendByte(StartAddress >> 8);\r
-                       SPI_SendByte(StartAddress & 0xFF);\r
-                       SPI_SendByte(0x00);\r
+                       SPI_Send(Write_Memory_Params.ProgrammingCommands[1]);\r
+                       SPI_Send(StartAddress >> 8);\r
+                       SPI_Send(StartAddress & 0xFF);\r
+                       SPI_Send(0x00);\r

                        \r
                        /* Check if polling is possible, if not switch to timed delay mode */\r
                        if (!(PollAddress))\r
                        \r
                        /* Check if polling is possible, if not switch to timed delay mode */\r
                        if (!(PollAddress))\r


@@ -254,10 +254,10 @@ void ISPProtocol_ProgramMemory(uint8_t V2Command)
                        bool    IsOddByte   = (CurrentByte & 0x01);\r
                        uint8_t ByteToWrite = *(NextWriteByte++);\r
                          \r
                        bool    IsOddByte   = (CurrentByte & 0x01);\r
                        uint8_t ByteToWrite = *(NextWriteByte++);\r
                          \r

-                       SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);\r
-                       SPI_SendByte(CurrentAddress >> 8);\r
-                       SPI_SendByte(CurrentAddress & 0xFF);\r
-                       SPI_SendByte(ByteToWrite);\r
+                       SPI_Send(Write_Memory_Params.ProgrammingCommands[0]);\r
+                       SPI_Send(CurrentAddress >> 8);\r
+                       SPI_Send(CurrentAddress & 0xFF);\r
+                       SPI_Send(ByteToWrite);\r

                        \r
                        /* AVR FLASH addressing requires us to modify the write command based on if we are writing a high\r
                         * or low byte at the current word address */\r
                        \r
                        /* AVR FLASH addressing requires us to modify the write command based on if we are writing a high\r
                         * or low byte at the current word address */\r


@@ -325,10 +325,10 @@ void ISPProtocol_ReadMemory(uint8_t V2Command)
        for (uint16_t CurrentByte = 0; CurrentByte < Read_Memory_Params.BytesToRead; CurrentByte++)\r
        {\r
                /* Read the next byte from the desired memory space in the device */\r
        for (uint16_t CurrentByte = 0; CurrentByte < Read_Memory_Params.BytesToRead; CurrentByte++)\r
        {\r
                /* Read the next byte from the desired memory space in the device */\r

-               SPI_SendByte(Read_Memory_Params.ReadMemoryCommand);\r
-               SPI_SendByte(CurrentAddress >> 8);\r
-               SPI_SendByte(CurrentAddress & 0xFF);\r
-               Endpoint_Write_Byte(SPI_ReceiveByte());\r
+               SPI_Send(Read_Memory_Params.ReadMemoryCommand);\r
+               SPI_Send(CurrentAddress >> 8);\r
+               SPI_Send(CurrentAddress & 0xFF);\r
+               Endpoint_Write_Byte(SPI_Receive());\r

                \r
                /* Check if the endpoint bank is currently full, if so send the packet */\r
                if (!(Endpoint_IsReadWriteAllowed()))\r
                \r
                /* Check if the endpoint bank is currently full, if so send the packet */\r
                if (!(Endpoint_IsReadWriteAllowed()))\r


@@ -381,7 +381,7 @@ void ISPProtocol_ChipErase(void)
        \r
        /* Send the chip erase commands as given by the host to the device */\r
        for (uint8_t SByte = 0; SByte < sizeof(Erase_Chip_Params.EraseCommandBytes); SByte++)\r
        \r
        /* Send the chip erase commands as given by the host to the device */\r
        for (uint8_t SByte = 0; SByte < sizeof(Erase_Chip_Params.EraseCommandBytes); SByte++)\r

-         SPI_SendByte(Erase_Chip_Params.EraseCommandBytes[SByte]);\r
+         SPI_Send(Erase_Chip_Params.EraseCommandBytes[SByte]);\r

 \r
        /* Use appropriate command completion check as given by the host (delay or busy polling) */\r
        if (!(Erase_Chip_Params.PollMethod))\r
 \r
        /* Use appropriate command completion check as given by the host (delay or busy polling) */\r
        if (!(Erase_Chip_Params.PollMethod))\r


@@ -416,7 +416,7 @@ void ISPProtocol_ReadFuseLockSigOSCCAL(uint8_t V2Command)
 \r
        /* Send the Fuse or Lock byte read commands as given by the host to the device, store response */\r
        for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)\r
 \r
        /* Send the Fuse or Lock byte read commands as given by the host to the device, store response */\r
        for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)\r

-         ResponseBytes[RByte] = SPI_TransferByte(Read_FuseLockSigOSCCAL_Params.ReadCommandBytes[RByte]);\r
+         ResponseBytes[RByte] = SPI_Transfer(Read_FuseLockSigOSCCAL_Params.ReadCommandBytes[RByte]);\r

                \r
        Endpoint_Write_Byte(V2Command);\r
        Endpoint_Write_Byte(STATUS_CMD_OK);\r
                \r
        Endpoint_Write_Byte(V2Command);\r
        Endpoint_Write_Byte(STATUS_CMD_OK);\r


@@ -444,7 +444,7 @@ void ISPProtocol_WriteFuseLock(uint8_t V2Command)
 \r
        /* Send the Fuse or Lock byte program commands as given by the host to the device */\r
        for (uint8_t SByte = 0; SByte < sizeof(Write_FuseLockSig_Params.WriteCommandBytes); SByte++)\r
 \r
        /* Send the Fuse or Lock byte program commands as given by the host to the device */\r
        for (uint8_t SByte = 0; SByte < sizeof(Write_FuseLockSig_Params.WriteCommandBytes); SByte++)\r

-         SPI_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);\r
+         SPI_Send(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);\r

                \r
        Endpoint_Write_Byte(V2Command);\r
        Endpoint_Write_Byte(STATUS_CMD_OK);\r
                \r
        Endpoint_Write_Byte(V2Command);\r
        Endpoint_Write_Byte(STATUS_CMD_OK);\r


@@ -479,9 +479,9 @@ void ISPProtocol_SPIMulti(void)
        while (CurrTxPos < SPI_Multi_Params.RxStartAddr)\r
        {\r
                if (CurrTxPos < SPI_Multi_Params.TxBytes)\r
        while (CurrTxPos < SPI_Multi_Params.RxStartAddr)\r
        {\r
                if (CurrTxPos < SPI_Multi_Params.TxBytes)\r

-                 SPI_SendByte(SPI_Multi_Params.TxData[CurrTxPos]);\r
+                 SPI_Send(SPI_Multi_Params.TxData[CurrTxPos]);\r

                else\r
                else\r

-                 SPI_SendByte(0);\r
+                 SPI_Send(0);\r

                \r
                CurrTxPos++;\r
        }\r
                \r
                CurrTxPos++;\r
        }\r


@@ -490,9 +490,9 @@ void ISPProtocol_SPIMulti(void)
        while (CurrRxPos < SPI_Multi_Params.RxBytes)\r
        {\r
                if (CurrTxPos < SPI_Multi_Params.TxBytes)\r
        while (CurrRxPos < SPI_Multi_Params.RxBytes)\r
        {\r
                if (CurrTxPos < SPI_Multi_Params.TxBytes)\r

-                 Endpoint_Write_Byte(SPI_TransferByte(SPI_Multi_Params.TxData[CurrTxPos++]));\r
+                 Endpoint_Write_Byte(SPI_Transfer(SPI_Multi_Params.TxData[CurrTxPos++]));\r

                else\r
                else\r

-                 Endpoint_Write_Byte(SPI_ReceiveByte());\r
+                 Endpoint_Write_Byte(SPI_Receive());\r

                  \r
                /* Check to see if we have filled the endpoint bank and need to send the packet */\r
                if (!(Endpoint_IsReadWriteAllowed()))\r
                  \r
                /* Check to see if we have filled the endpoint bank and need to send the packet */\r
                if (!(Endpoint_IsReadWriteAllowed()))\r

diff --git a/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c b/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c
index 94f1c3d..b657758 100644 (file)
--- a/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c
+++ b/Projects/AVRISP-MKII/Lib/ISP/ISPTarget.c
@@ -131,11 +131,11 @@ uint8_t ISPTarget_WaitForProgComplete(const uint8_t ProgrammingMode, const uint1
                                        TimeoutMSRemaining--;\r
                                }\r
 \r
                                        TimeoutMSRemaining--;\r
                                }\r
 \r

-                               SPI_SendByte(ReadMemCommand);\r
-                               SPI_SendByte(PollAddress >> 8);\r
-                               SPI_SendByte(PollAddress & 0xFF);\r
+                               SPI_Send(ReadMemCommand);\r
+                               SPI_Send(PollAddress >> 8);\r
+                               SPI_Send(PollAddress & 0xFF);\r

                        }\r
                        }\r

-                       while ((SPI_TransferByte(0x00) == PollValue) && TimeoutMSRemaining);\r
+                       while ((SPI_Transfer(0x00) == PollValue) && TimeoutMSRemaining);\r

 \r
                        if (!(TimeoutMSRemaining))\r
                         ProgrammingStatus = STATUS_CMD_TOUT;\r
 \r
                        if (!(TimeoutMSRemaining))\r
                         ProgrammingStatus = STATUS_CMD_TOUT;\r


@@ -169,11 +169,11 @@ uint8_t ISPTarget_WaitWhileTargetBusy(void)
                        TimeoutMSRemaining--;\r
                }       \r
 \r
                        TimeoutMSRemaining--;\r
                }       \r
 \r

-               SPI_SendByte(0xF0);\r
-               SPI_SendByte(0x00);\r
-               SPI_SendByte(0x00);\r
+               SPI_Send(0xF0);\r
+               SPI_Send(0x00);\r
+               SPI_Send(0x00);\r

        }\r
        }\r

-       while ((SPI_ReceiveByte() & 0x01) && TimeoutMSRemaining);\r
+       while ((SPI_Receive() & 0x01) && TimeoutMSRemaining);\r

 \r
        if (TimeoutMSRemaining)\r
        {\r
 \r
        if (TimeoutMSRemaining)\r
        {\r


@@ -192,10 +192,10 @@ uint8_t ISPTarget_WaitWhileTargetBusy(void)
  */\r
 void ISPTarget_LoadExtendedAddress(void)\r
 {\r
  */\r
 void ISPTarget_LoadExtendedAddress(void)\r
 {\r

-       SPI_SendByte(LOAD_EXTENDED_ADDRESS_CMD);\r
-       SPI_SendByte(0x00);\r
-       SPI_SendByte((CurrentAddress & 0x00FF0000) >> 16);\r
-       SPI_SendByte(0x00);     \r
+       SPI_Send(LOAD_EXTENDED_ADDRESS_CMD);\r
+       SPI_Send(0x00);\r
+       SPI_Send((CurrentAddress & 0x00FF0000) >> 16);\r
+       SPI_Send(0x00); \r

 }\r
 \r
 #endif\r
 }\r
 \r
 #endif\r