Changeset 224 for rtos_arduino

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/boards.txt

-              r136
+              r224
+######################################################
 #ARDUINO M0 PRO (WITH) BOOTLOADER - PROGRAMMING PORT
 arduino_zero_pro_bl_dbg.name=Arduino M0 Pro (Programming Port)
 arduino_zero_pro_bl_dbg.vid.0=0x03eb
 arduino_zero_pro_bl_dbg.pid.0=0x2111
 arduino_zero_pro_bl_dbg.upload.tool=openocd
 arduino_zero_pro_bl_dbg.upload.protocol=sam-ba
 arduino_zero_pro_bl_dbg.upload.maximum_size=262144
 arduino_zero_pro_bl_dbg.upload.use_1200bps_touch=false
 arduino_zero_pro_bl_dbg.upload.wait_for_upload_port=false
 arduino_zero_pro_bl_dbg.upload.native_usb=false
 arduino_zero_pro_bl_dbg.build.mcu=cortex-m0plus
 arduino_zero_pro_bl_dbg.build.f_cpu=48000000L
 arduino_zero_pro_bl_dbg.build.usb_product="Arduino M0 Pro"
 arduino_zero_pro_bl_dbg.build.board=SAM_ZERO
 arduino_zero_pro_bl_dbg.build.core=arduino
 arduino_zero_pro_bl_dbg.build.extra_flags=-D__SAMD21G18A__ -mthumb {build.usb_flags}
 arduino_zero_pro_bl_dbg.build.ldscript=linker_scripts/gcc/flash_with_bootloader.ld
 arduino_zero_pro_bl_dbg.build.openocdscript=openocd_scripts/arduino_zero.cfg
 arduino_zero_pro_bl_dbg.build.variant=arduino_zero
 arduino_zero_pro_bl_dbg.build.variant_system_lib=
 arduino_zero_pro_bl_dbg.build.vid=0x2a03
 arduino_zero_pro_bl_dbg.build.pid=0x804f
 arduino_zero_pro_bl_dbg.build.section.start=0x4000
+mzero_pro_bl_dbg.name=Arduino M0 Pro (Programming Port)
+mzero_pro_bl_dbg.vid.0=0x03eb
+mzero_pro_bl_dbg.pid.0=0x2111
+mzero_pro_bl_dbg.upload.tool=openocd
+mzero_pro_bl_dbg.upload.protocol=sam-ba
+mzero_pro_bl_dbg.upload.maximum_size=262144
+mzero_pro_bl_dbg.upload.use_1200bps_touch=false
+mzero_pro_bl_dbg.upload.wait_for_upload_port=false
+mzero_pro_bl_dbg.upload.native_usb=false
+mzero_pro_bl_dbg.build.mcu=cortex-m0plus
+mzero_pro_bl_dbg.build.f_cpu=48000000L
+mzero_pro_bl_dbg.build.usb_product="Arduino M0 Pro"
+mzero_pro_bl_dbg.build.board=SAM_ZERO
+mzero_pro_bl_dbg.build.core=arduino
+mzero_pro_bl_dbg.build.extra_flags=-D__SAMD21G18A__ -mthumb {build.usb_flags}
+mzero_pro_bl_dbg.build.ldscript=linker_scripts/gcc/flash_with_bootloader.ld
+mzero_pro_bl_dbg.build.openocdscript=openocd_scripts/arduino_zero.cfg
+mzero_pro_bl_dbg.build.variant=arduino_zero
+mzero_pro_bl_dbg.build.variant_system_lib=
+mzero_pro_bl_dbg.build.vid=0x2a03
+mzero_pro_bl_dbg.build.pid=0x804f
+mzero_pro_bl_dbg.build.section.start=0x4000
 arduino_zero_pro_bl_dbg.bootloader.tool=openocd
 arduino_zero_pro_bl_dbg.bootloader.cmd_unprotect=at91samd bootloader 0
 arduino_zero_pro_bl_dbg.bootloader.cmd_protect=at91samd bootloader 16384
 arduino_zero_pro_bl_dbg.bootloader.cmd_protect_verify=at91samd bootloader
 arduino_zero_pro_bl_dbg.bootloader.file=zero/Bootloader_D21_M0_Pro_150427.hex
+mzero_pro_bl_dbg.bootloader.tool=openocd
+mzero_pro_bl_dbg.bootloader.cmd_unprotect=at91samd bootloader 0
+mzero_pro_bl_dbg.bootloader.cmd_protect=at91samd bootloader 16384
+mzero_pro_bl_dbg.bootloader.cmd_protect_verify=at91samd bootloader
+mzero_pro_bl_dbg.bootloader.file=zero/Bootloader_D21_M0_Pro_150427.hex
+######################################################
 #ARDUINO M0 PRO (WITH) BOOTLOADER - NATIVE PORT
 arduino_zero_pro_bl.name=Arduino M0 Pro (Native USB Port)
 arduino_zero_pro_bl.vid.0=0x2a03
 arduino_zero_pro_bl.pid.0=0x004d
 arduino_zero_pro_bl.vid.1=0x2a03
 arduino_zero_pro_bl.pid.1=0x804d
 arduino_zero_pro_bl.vid.2=0x2a03
 arduino_zero_pro_bl.pid.2=0x004f
 arduino_zero_pro_bl.vid.3=0x2a03
 arduino_zero_pro_bl.pid.3=0x804f
 arduino_zero_pro_bl.upload.tool=avrdude
 arduino_zero_pro_bl.upload.protocol=stk500v2
 arduino_zero_pro_bl.upload.maximum_size=262144
 arduino_zero_pro_bl.upload.use_1200bps_touch=true
 arduino_zero_pro_bl.upload.wait_for_upload_port=true
 arduino_zero_pro_bl.upload.native_usb=true
 arduino_zero_pro_bl.upload.speed=57600
 arduino_zero_pro_bl.build.mcu=cortex-m0plus
 arduino_zero_pro_bl.build.f_cpu=48000000L
 arduino_zero_pro_bl.build.usb_product="Arduino M0 Pro"
 arduino_zero_pro_bl.build.board=SAM_ZERO
 arduino_zero_pro_bl.build.core=arduino
 arduino_zero_pro_bl.build.extra_flags=-D__SAMD21G18A__ -mthumb {build.usb_flags}
 arduino_zero_pro_bl.build.ldscript=linker_scripts/gcc/flash_with_bootloader.ld
 arduino_zero_pro_bl.build.variant=arduino_zero
 arduino_zero_pro_bl.build.variant_system_lib=
 arduino_zero_pro_bl.build.vid=0x2a03
 arduino_zero_pro_bl.build.pid=0x804f
 arduino_zero_pro_bl.build.section.start=0x4000
 arduino_zero_pro_bl.build.emu.mcu=atmega2560
 arduino_zero_pro_bl.bootloader.tool=avrdude
 arduino_zero_pro_bl.bootloader.low_fuses=0xff
+mzero_pro_bl.name=Arduino M0 Pro (Native USB Port)
+mzero_pro_bl.vid.0=0x2a03
+mzero_pro_bl.pid.0=0x004d
+mzero_pro_bl.vid.1=0x2a03
+mzero_pro_bl.pid.1=0x804d
+mzero_pro_bl.vid.2=0x2a03
+mzero_pro_bl.pid.2=0x004f
+mzero_pro_bl.vid.3=0x2a03
+mzero_pro_bl.pid.3=0x804f
+mzero_pro_bl.upload.tool=avrdude
+mzero_pro_bl.upload.protocol=stk500v2
+mzero_pro_bl.upload.maximum_size=262144
+mzero_pro_bl.upload.use_1200bps_touch=true
+mzero_pro_bl.upload.wait_for_upload_port=true
+mzero_pro_bl.upload.native_usb=true
+mzero_pro_bl.upload.speed=57600
+mzero_pro_bl.build.mcu=cortex-m0plus
+mzero_pro_bl.build.f_cpu=48000000L
+mzero_pro_bl.build.usb_product="Arduino M0 Pro"
+mzero_pro_bl.build.board=SAM_ZERO
+mzero_pro_bl.build.core=arduino
+mzero_pro_bl.build.extra_flags=-D__SAMD21G18A__ -mthumb {build.usb_flags}
+mzero_pro_bl.build.ldscript=linker_scripts/gcc/flash_with_bootloader.ld
+mzero_pro_bl.build.variant=arduino_zero
+mzero_pro_bl.build.variant_system_lib=
+mzero_pro_bl.build.vid=0x2a03
+mzero_pro_bl.build.pid=0x804f
+mzero_pro_bl.build.section.start=0x4000
+mzero_pro_bl.build.emu.mcu=atmega2560
+mzero_pro_bl.bootloader.tool=avrdude
+mzero_pro_bl.bootloader.low_fuses=0xff
+######################################################
 #ARDUINO M0 (WITH) BOOTLOADER
+arduino_zero_bl.name=Arduino M0
+arduino_zero_bl.vid.0=0x2a03
+arduino_zero_bl.pid.0=0x004d
+arduino_zero_bl.vid.1=0x2a03
+arduino_zero_bl.pid.1=0x804d
+arduino_zero_bl.vid.2=0x2a03
+arduino_zero_bl.pid.2=0x004e
+arduino_zero_bl.vid.3=0x2a03
+arduino_zero_bl.pid.3=0x804e
+arduino_zero_bl.upload.tool=avrdude
+arduino_zero_bl.upload.protocol=stk500v2
+arduino_zero_bl.upload.maximum_size=262144
+arduino_zero_bl.upload.use_1200bps_touch=true
+arduino_zero_bl.upload.wait_for_upload_port=true
+arduino_zero_bl.upload.native_usb=true
+arduino_zero_bl.upload.speed=57600
+arduino_zero_bl.build.mcu=cortex-m0plus
+arduino_zero_bl.build.f_cpu=48000000L
+arduino_zero_bl.build.usb_product="Arduino M0"
+arduino_zero_bl.build.board=SAM_ZERO
+arduino_zero_bl.build.core=arduino
+arduino_zero_bl.build.extra_flags=-D__SAMD21G18A__ -mthumb {build.usb_flags}
+arduino_zero_bl.build.ldscript=linker_scripts/gcc/flash_with_bootloader.ld
+arduino_zero_bl.build.variant=arduino_zero
+arduino_zero_bl.build.variant_system_lib=
+arduino_zero_bl.build.vid=0x2a03
+arduino_zero_bl.build.pid=0x804e
+arduino_zero_bl.build.section.start=0x4000
+arduino_zero_bl.build.emu.mcu=atmega2560
+arduino_zero_bl.bootloader.tool=avrdude
+arduino_zero_bl.bootloader.low_fuses=0xff
+mzero_bl.name=Arduino M0
+mzero_bl.vid.0=0x2a03
+mzero_bl.pid.0=0x004d
+mzero_bl.vid.1=0x2a03
+mzero_bl.pid.1=0x804d
+mzero_bl.vid.2=0x2a03
+mzero_bl.pid.2=0x004e
+mzero_bl.vid.3=0x2a03
+mzero_bl.pid.3=0x804e
+mzero_bl.upload.tool=avrdude
+mzero_bl.upload.protocol=stk500v2
+mzero_bl.upload.maximum_size=262144
+mzero_bl.upload.use_1200bps_touch=true
+mzero_bl.upload.wait_for_upload_port=true
+mzero_bl.upload.native_usb=true
+mzero_bl.upload.speed=57600
+mzero_bl.build.mcu=cortex-m0plus
+mzero_bl.build.f_cpu=48000000L
+mzero_bl.build.usb_product="Arduino M0"
+mzero_bl.build.board=SAM_ZERO
+mzero_bl.build.core=arduino
+mzero_bl.build.extra_flags=-D__SAMD21G18A__ -mthumb {build.usb_flags}
+mzero_bl.build.ldscript=linker_scripts/gcc/flash_with_bootloader.ld
+mzero_bl.build.variant=arduino_zero
+mzero_bl.build.variant_system_lib=
+mzero_bl.build.vid=0x2a03
+mzero_bl.build.pid=0x804e
+mzero_bl.build.section.start=0x4000
+mzero_bl.build.emu.mcu=atmega2560
+mzero_bl.bootloader.tool=avrdude
+mzero_bl.bootloader.low_fuses=0xff
+######################################################
+#ARDUINO TIAN (WITH) BOOTLOADER
+tian.name=Arduino Tian
+tian.upload.via_ssh=true
+tian.vid.0=0x10C4
+tian.pid.0=0xEA70
+tian.upload.tool=avrdude
+#tian.upload.protocol=stk500v2
+tian.upload.protocol=wiring
+tian.upload.maximum_size=262144
+tian.upload.use_1200bps_touch=true
+tian.upload.wait_for_upload_port=true
+tian.upload.native_usb=true
+tian.upload.speed=57600
+tian.build.mcu=cortex-m0plus
+tian.build.f_cpu=48000000L
+tian.build.usb_product="Arduino Tian"
+tian.build.board=SAMD_TIAN
+tian.build.core=arduino
+tian.build.extra_flags=-D__SAMD21G18A__ -mthumb {build.usb_flags}
+tian.build.ldscript=linker_scripts/gcc/flash_with_bootloader.ld
+tian.build.variant=arduino_zero
+tian.build.variant_system_lib=
+tian.build.vid=0x2a03
+tian.build.pid=0x8052
+tian.build.section.start=0x4000
+tian.build.emu.mcu=atmega2560
+tian.bootloader.tool=avrdude
+tian.bootloader.low_fuses=0xff
+tian.bootloader.file=sofia/Sofia_Tian_151118.hex
+tian.drivers=SiliconLabs-CP2105/Silicon Labs VCP Driver.pkg

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/Print.cpp

r136	r224
115	115	size_t Print::println(void)
116	116	{
117		size_t n = print('\r');
118		n += print('\n');
119		return n;
	117	return write("\r\n");
120	118	}
121	119

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/CDC.cpp

-              r136
+              r224
+/* Copyright (c) 2011, Peter Barrett
+**
+** Permission to use, copy, modify, and/or distribute this software for
+** any purpose with or without fee is hereby granted, provided that the
+** above copyright notice and this permission notice appear in all copies.
+**
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+** SOFTWARE.
+/*
+  Copyright (c) 2015 Arduino LLC.  All right reserved.
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+** Modified 04/04/2016 by Arduino.org development team
 */
 …
 // Include Atmel headers
+#include "Arduino.h"
+#include "sam.h"
+#include "wiring_constants.h"
+#include "USBCore.h"
+#include "USB/USB_device.h"
+#include "USBDesc.h"
+#include "USBAPI.h"
+#include "Reset.h"
+#include <Arduino.h>
+#include <Reset.h>
 #ifdef CDC_ENABLED
 #define CDC_SERIAL_BUFFER_SIZE  64
+#define CDC_SERIAL_BUFFER_SIZE  256
 /* For information purpose only since RTS is not always handled by the terminal application */
 …
 #define CDC_LINESTATE_READY             (CDC_LINESTATE_RTS | CDC_LINESTATE_DTR)
+struct ring_buffer
+{
+struct ring_buffer {
         uint8_t buffer[CDC_SERIAL_BUFFER_SIZE];
         volatile uint32_t head;
         volatile uint32_t tail;
+        volatile bool full;
 };
+ring_buffer cdc_rx_buffer = { { 0 }, 0, 0};
+typedef struct
+{
+        uint32_t        dwDTERate;
+        uint8_t         bCharFormat;
+        uint8_t         bParityType;
+        uint8_t         bDataBits;
+        uint8_t         lineState;
+ring_buffer cdc_rx_buffer = {{0}, 0, 0, false};
+typedef struct {
+        uint32_t dwDTERate;
+        uint8_t bCharFormat;
+        uint8_t bParityType;
+        uint8_t bDataBits;
+        uint8_t lineState;
 } LineInfo;
 _Pragma("pack(1)")
 static volatile LineInfo _usbLineInfo = {
 , // dWDTERate
 x00,  // bCharFormat
 x00,  // bParityType
 x08,  // bDataBits
 x00   // lineState
+static volatile LineInfo _usbLineInfo = {
+, // dWDTERate
+x00,   // bCharFormat
+x00,   // bParityType
+x08,   // bDataBits
+x00    // lineState
 };
 static const CDCDescriptor _cdcInterface =
+{
+#if (defined CDC_ENABLED) && defined(HID_ENABLED)
+static volatile int32_t breakValue = -1;
+static CDCDescriptor _cdcInterface = {
         D_IAD(0, 2, CDC_COMMUNICATION_INTERFACE_CLASS, CDC_ABSTRACT_CONTROL_MODEL, 0),
+#endif
         //      CDC communication interface
         D_INTERFACE(CDC_ACM_INTERFACE,1,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,0),
         D_CDCCS( CDC_HEADER, CDC_V1_10 & 0xFF, (CDC_V1_10>>8) & 0x0FF ),        // Header (1.10 bcd)
         D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT,6),                            // SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
         D_CDCCS(CDC_UNION,CDC_ACM_INTERFACE,CDC_DATA_INTERFACE),        // Communication interface is master, data interface is slave 0
         D_CDCCS(CDC_CALL_MANAGEMENT,1,1),                                                       // Device handles call management (not)
         D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_ACM),USB_ENDPOINT_TYPE_INTERRUPT,0x10, 0x10),
         //      CDC data interface
         D_INTERFACE(CDC_DATA_INTERFACE,2,CDC_DATA_INTERFACE_CLASS,0,0),
         D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT),USB_ENDPOINT_TYPE_BULK,EPX_SIZE,0),
         D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ),USB_ENDPOINT_TYPE_BULK,EPX_SIZE,0)
+        // CDC communication interface
+        D_INTERFACE(CDC_ACM_INTERFACE, 1, CDC_COMMUNICATION_INTERFACE_CLASS, CDC_ABSTRACT_CONTROL_MODEL, 0),
+        D_CDCCS(CDC_HEADER, CDC_V1_10 & 0xFF, (CDC_V1_10>>8) & 0x0FF), // Header (1.10 bcd)
+        D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT, 6), // SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
+        D_CDCCS(CDC_UNION, CDC_ACM_INTERFACE, CDC_DATA_INTERFACE), // Communication interface is master, data interface is slave 0
+        D_CDCCS(CDC_CALL_MANAGEMENT, 1, 1), // Device handles call management (not)
+        D_ENDPOINT(USB_ENDPOINT_IN(CDC_ENDPOINT_ACM), USB_ENDPOINT_TYPE_INTERRUPT, 0x10, 0x10),
+        // CDC data interface
+        D_INTERFACE(CDC_DATA_INTERFACE, 2, CDC_DATA_INTERFACE_CLASS, 0, 0),
+        D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT), USB_ENDPOINT_TYPE_BULK, EPX_SIZE, 0),
+        D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ), USB_ENDPOINT_TYPE_BULK, EPX_SIZE, 0)
 };
 _Pragma("pack()")
+const void* WEAK CDC_GetInterface(void)
+{
+        return  &_cdcInterface;
+}
+uint32_t WEAK CDC_GetInterfaceLength(void)
+{
+    return sizeof( _cdcInterface );
+}
+bool WEAK CDC_Setup(Setup& setup)
+{
+        uint8_t r = setup.bRequest;
+        uint8_t requestType = setup.bmRequestType;
+const void* _CDC_GetInterface(void)
+{
+        return &_cdcInterface;
+}
+uint32_t _CDC_GetInterfaceLength(void)
+{
+        return sizeof(_cdcInterface);
+}
+int CDC_GetInterface(uint8_t* interfaceNum)
+{
+        interfaceNum[0] += 2;   // uses 2
+        return USBD_SendControl(&_cdcInterface,sizeof(_cdcInterface));
+}
+bool CDC_Setup(Setup& pSetup)
+{
+        uint8_t requestType = pSetup.bmRequestType;
+        uint8_t r = pSetup.bRequest;
         if (REQUEST_DEVICETOHOST_CLASS_INTERFACE == requestType)
 …
                 if (CDC_GET_LINE_CODING == r)
+                {
                         USBD_SendControl(0,(void*)&_usbLineInfo,7);
+                        USBD_SendControl((void*)&_usbLineInfo, 7);
                         return true;
+                }
 …
                 if (CDC_SET_LINE_CODING == r)
+                {
+                        while( UDD_FifoByteCount(EP0) <15);
+                        //USBD_RecvControl((void*)&_usbLineInfo,7);
+                        uint8_t* line = (uint8_t*)&_usbLineInfo;
+                        for(uint8_t i = 0; i<7; i++)
+                                line[i] = setup.data[i];
+                        return false;
+                        USBD_RecvControl((void*)&_usbLineInfo, 7);
+                }
                 if (CDC_SET_CONTROL_LINE_STATE == r)
+                {
+                        _usbLineInfo.lineState = setup.wValueL;
+                        _usbLineInfo.lineState = pSetup.wValueL;
+                }
+                if (r == CDC_SET_LINE_CODING || r == CDC_SET_CONTROL_LINE_STATE)
+                {
                         // auto-reset into the bootloader is triggered when the port, already
+                        // open at 1200 bps, is closed.
+                        if (1200 == _usbLineInfo.dwDTERate)
+                        // open at 1200 bps, is closed. We check DTR state to determine if host
+                        // port is open (bit 0 of lineState).
+                        if (_usbLineInfo.dwDTERate == 1200 && (_usbLineInfo.lineState & 0x01) == 0)
+                        {
                                 // We check DTR state to determine if host port is open (bit 0 of lineState).
                                 if ((_usbLineInfo.lineState & 0x01) == 0)
                                         initiateReset(250);
                                 else
                                         cancelReset();
+                                initiateReset(250);
+                        }
+                        else
+                        {
+                                cancelReset();
+                        }
                         return false;
+                }
+                if (r == CDC_SEND_BREAK)
+                {
+                        breakValue = ((uint16_t)pSetup.wValueH << 8) | pSetup.wValueL;
+                        return false;
+                }
+        }
         return false;
 …
 void Serial_::accept(void)
+{
+        uint8_t buffer[CDC_SERIAL_BUFFER_SIZE];
+        uint32_t len = USBD_Recv(CDC_ENDPOINT_OUT, &buffer, CDC_SERIAL_BUFFER_SIZE);
+        uint8_t enableInterrupts = ((__get_PRIMASK() & 0x1) == 0);
+        __disable_irq();
+        ring_buffer *ringBuffer = &cdc_rx_buffer;
+        uint32_t i = ringBuffer->head;
+        uint32_t k = 0;
+        while (len > 0 && !ringBuffer->full) {
+                len--;
+                ringBuffer->buffer[i++] = buffer[k++];
+                i %= CDC_SERIAL_BUFFER_SIZE;
+                if (i == ringBuffer->tail)
+                        ringBuffer->full = true;
+        }
+        ringBuffer->head = i;
+        if (enableInterrupts) {
+                __enable_irq();
+        }
+}
+int Serial_::available(void)
+{
         ring_buffer *buffer = &cdc_rx_buffer;
+        uint32_t i = (uint32_t)(buffer->head+1) % CDC_SERIAL_BUFFER_SIZE;
+        // 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.
+        while (i != buffer->tail) {
+                uint32_t c;
+                if (!USBD_Available(CDC_ENDPOINT_OUT)) {
+            UDD_ReleaseRX(CDC_ENDPOINT_OUT);
+                        break;
+                }
+                c = USBD_Recv(CDC_ENDPOINT_OUT);
+                buffer->buffer[buffer->head] = c;
+                buffer->head = i;
+                i = (i + 1) % CDC_SERIAL_BUFFER_SIZE;
+        }
+}
+int Serial_::available(void)
+        if (buffer->full) {
+                return CDC_SERIAL_BUFFER_SIZE;
+        }
+        if (buffer->head == buffer->tail) {
+                USB->DEVICE.DeviceEndpoint[CDC_ENDPOINT_OUT].EPINTENSET.reg = USB_DEVICE_EPINTENCLR_TRCPT(1);
+        }
+        return (uint32_t)(CDC_SERIAL_BUFFER_SIZE + buffer->head - buffer->tail) % CDC_SERIAL_BUFFER_SIZE;
+}
+int Serial_::peek(void)
+{
         ring_buffer *buffer = &cdc_rx_buffer;
+        return (uint32_t)(CDC_SERIAL_BUFFER_SIZE + buffer->head - buffer->tail) % CDC_SERIAL_BUFFER_SIZE;
+}
+int Serial_::peek(void)
+        if (buffer->head == buffer->tail && !buffer->full) {
+                return -1;
+        } else {
+                return buffer->buffer[buffer->tail];
+        }
+}
+// if the ringBuffer is empty: try to fill it
+// if it's still empty: return -1
+// else return the last char
+// so the buffer is filled only when needed
+int Serial_::read(void)
+{
         ring_buffer *buffer = &cdc_rx_buffer;
-        if (buffer->head == buffer->tail)
+        {
-                return -1;
+        }
-        else
+        {
-                return buffer->buffer[buffer->tail];
+        }
+}
-int Serial_::read(void)
+{
-        ring_buffer *buffer = &cdc_rx_buffer;
         // if the head isn't ahead of the tail, we don't have any characters
+        if (buffer->head == buffer->tail)
+        if (buffer->head == buffer->tail && !buffer->full)
+        {
+                if (USBD_Available(CDC_ENDPOINT_OUT))
+                        accept();
+        }
+        if (buffer->head == buffer->tail && !buffer->full)
+        {
                 return -1;
 …
                 unsigned char c = buffer->buffer[buffer->tail];
                 buffer->tail = (uint32_t)(buffer->tail + 1) % CDC_SERIAL_BUFFER_SIZE;
+                if (USBD_Available(CDC_ENDPOINT_OUT))
+                        accept();
+                buffer->full = false;
                 return c;
+        }
 …
          bytes sent before the user opens the connection or after
          the connection is closed are lost - just like with a UART. */
+        if (_usbLineInfo.lineState > 0)  // Problem with Windows(R)
+        {
                 uint32_t r = USBD_Send(CDC_ENDPOINT_IN, buffer, size);
+                if (r > 0)
+                {
+                if (r == 0) {
                         return r;
+                } else
+                {
+                } else {
                         setWriteError();
                         return 0;
+                }
+        }
+         }
         setWriteError();
         return 0;
 …
 // We add a short delay before returning to fix a bug observed by Federico
 // where the port is configured (lineState != 0) but not quite opened.
 Serial_::operator bool()
+{
 …
+}
+Serial_ SerialUSB;
+int32_t Serial_::readBreak() {
+        uint8_t enableInterrupts = ((__get_PRIMASK() & 0x1) == 0);
+        // disable interrupts,
+        // to avoid clearing a breakValue that might occur
+        // while processing the current break value
+        __disable_irq();
+        int32_t ret = breakValue;
+        breakValue = -1;
+        if (enableInterrupts) {
+                // re-enable the interrupts
+                __enable_irq();
+        }
+        return ret;
+}
+unsigned long Serial_::baud() {
+        return _usbLineInfo.dwDTERate;
+}
+uint8_t Serial_::stopbits() {
+        return _usbLineInfo.bCharFormat;
+}
+uint8_t Serial_::paritytype() {
+        return _usbLineInfo.bParityType;
+}
+uint8_t Serial_::numbits() {
+        return _usbLineInfo.bDataBits;
+}
+bool Serial_::dtr() {
+        return _usbLineInfo.lineState & 0x1;
+}
+bool Serial_::rts() {
+        return _usbLineInfo.lineState & 0x2;
+}
+Serial_ SerialUSB(USBDevice);
 #endif

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/HID.cpp

-              r136
+              r224
 #include "USBDesc.h"
 #include "sam.h"
-#include "USB/USB_device.h"
 …
 //      HID report descriptor
 _Pragma("pack(1)")
 extern const uint8_t _hidReportDescriptor[] = {
+extern const uint32_t _hidReportDescriptor[] = {
         //      Mouse
 x05, 0x01,                    //   USAGE_PAGE (Generic Desktop)    // 54
 …
 uint32_t WEAK HID_GetDescriptor(void)
+{
         return USBD_SendControl(0,_hidReportDescriptor,sizeof(_hidReportDescriptor));
+        return USBD_SendControl(_hidReportDescriptor,sizeof(_hidReportDescriptor));
+}
 …
                 if (HID_GET_IDLE == r)
+                {
                         UDD_Send(0, &_hid_idle, 1);
                         UDD_ClearIN();
+                        USBD_Send(0, &_hid_idle, 1);
+                        USB->DEVICE.DeviceEndpoint[EP0].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_BK1RDY;
                         return true;
+                }

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USBAPI.h

-              r136
+              r224
 /*
   Copyright (c) 2012 Arduino.  All right reserved.
+  Copyright (c) 2015 Arduino LLC.  All right reserved.
   This library is free software; you can redistribute it and/or
 …
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
+#ifndef __USBAPI__
+#define __USBAPI__
+/* Define attribute */
+#if defined   ( __CC_ARM   ) /* Keil uVision 4 */
+    #define WEAK (__attribute__ ((weak)))
+#elif defined ( __ICCARM__ ) /* IAR Ewarm 5.41+ */
+    #define WEAK __weak
+#elif defined (  __GNUC__  ) /* GCC CS */
+    #define WEAK __attribute__ ((weak))
+#endif
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
+#pragma once
+#define WEAK __attribute__ ((weak))
+#define HSTPIPCFG_PTYPE_BLK 1
+#define HSTPIPCFG_PTOKEN_IN 2
+#define HSTPIPCFG_PTOKEN_OUT 3
+#define HSTPIPCFG_PBK_1_BANK 4
+#define HSTPIPCFG_PTYPE_INTRPT 5
+#define EP0      0
+#define EPX_SIZE 64 // 64 for Full Speed, EPT size max is 1024
 #if defined __cplusplus
 …
 //================================================================================
+//================================================================================
+//      USB
+class USBDevice_
+{
+public:
+        USBDevice_();
+// USB
+//================================================================================
+//================================================================================
+// Low level API
+typedef struct {
+        union {
+                uint8_t bmRequestType;
+                struct {
+                        uint8_t direction : 5;
+                        uint8_t type : 2;
+                        uint8_t transferDirection : 1;
+                };
+        };
+        uint8_t bRequest;
+        uint8_t wValueL;
+        uint8_t wValueH;
+        uint16_t wIndex;
+        uint16_t wLength;
+} Setup;
+class USBDevice_ {
+public:
+        USBDevice_() {};
+        // USB Device API
+        void init();
+        bool attach();  // Serial port goes down too...
+        bool detach();
         bool configured();
+        bool attach();
+        bool detach();  // Serial port goes down too...
+        void poll();
+        void init();
+};
+private:
+        bool initialized;
+};
 extern USBDevice_ USBDevice;
 //================================================================================
-//================================================================================
 //      Serial over CDC (Serial1 is the physical port)
 class Serial_ : public Stream
+{
+private:
+        RingBuffer *_cdc_rx_buffer;
+public:
+public:
+        Serial_(USBDevice_ &_usb) : usb(_usb) { }
         void begin(uint32_t baud_count);
         void begin(unsigned long, uint8_t);
 …
         using Print::write; // pull in write(str) from Print
         operator bool();
+        // This method allows processing "SEND_BREAK" requests sent by
+        // the USB host. Those requests indicate that the host wants to
+        // send a BREAK signal and are accompanied by a single uint16_t
+        // value, specifying the duration of the break. The value 0
+        // means to end any current break, while the value 0xffff means
+        // to start an indefinite break.
+        // readBreak() will return the value of the most recent break
+        // request, but will return it at most once, returning -1 when
+        // readBreak() is called again (until another break request is
+        // received, which is again returned once).
+        // This also mean that if two break requests are received
+        // without readBreak() being called in between, the value of the
+        // first request is lost.
+        // Note that the value returned is a long, so it can return
+        // 0-0xffff as well as -1.
+        int32_t readBreak();
+        // These return the settings specified by the USB host for the
+        // serial port. These aren't really used, but are offered here
+        // in case a sketch wants to act on these settings.
+        uint32_t baud();
+        uint8_t stopbits();
+        uint8_t paritytype();
+        uint8_t numbits();
+        bool dtr();
+        bool rts();
+        enum {
+                ONE_STOP_BIT = 0,
+                ONE_AND_HALF_STOP_BIT = 1,
+                TWO_STOP_BITS = 2,
+        };
+        enum {
+                NO_PARITY = 0,
+                ODD_PARITY = 1,
+                EVEN_PARITY = 2,
+                MARK_PARITY = 3,
+                SPACE_PARITY = 4,
+        };
+private:
+        USBDevice_ &usb;
+        RingBuffer *_cdc_rx_buffer;
 };
 extern Serial_ SerialUSB;
 …
 //================================================================================
 //================================================================================
-//      Low level API
-typedef struct
+{
-        uint8_t bmRequestType;
-        uint8_t bRequest;
-        uint8_t wValueL;
-        uint8_t wValueH;
-        uint16_t wIndex;
-        uint16_t wLength;
-        uint8_t data[8];
-} Setup;
-//================================================================================
-//================================================================================
 //      HID 'Driver'
 …
 uint32_t                MSC_GetInterface(uint8_t* interfaceNum);
 uint32_t                MSC_GetDescriptor(uint32_t i);
 bool    MSC_Setup(Setup& setup);
+bool    MSC_Setup(Setup& pSetup);
 bool    MSC_Data(uint8_t rx,uint8_t tx);
 …
 //      CDC 'Driver'
+const void* CDC_GetInterface(/*uint8_t* interfaceNum*/);
+uint32_t WEAK CDC_GetInterfaceLength(void);
+int CDC_GetInterface(uint8_t* interfaceNum);
+const void* _CDC_GetInterface(void);
+uint32_t _CDC_GetInterfaceLength(void);
 uint32_t                CDC_GetOtherInterface(uint8_t* interfaceNum);
 uint32_t                CDC_GetDescriptor(uint32_t i);
+bool    CDC_Setup(Setup& setup);
+//================================================================================
+//================================================================================
+uint32_t USBD_SendControl(uint8_t flags, const void* d, uint32_t len);
+bool    CDC_Setup(Setup& pSetup);
+//================================================================================
+//================================================================================
+uint32_t USBD_SendControl(const void* _data, uint32_t len);
 uint32_t USBD_RecvControl(void* d, uint32_t len);
+void USBD_Calibrate();
 uint32_t USBD_SendInterfaces(void);
 bool USBD_ClassInterfaceRequest(Setup& setup);
 …
 uint32_t USBD_Recv(uint32_t ep, void* data, uint32_t len);              // non-blocking
 uint32_t USBD_Recv(uint32_t ep);                                                        // non-blocking
+uint8_t USBD_armRecv(uint32_t ep);
 void USBD_Flush(uint32_t ep);
 uint32_t USBD_Connected(void);
 #endif  // __cplusplus
-#endif  // __USBAPI__

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USBCore.cpp

-              r136
+              r224
-// Copyright (c) 2010, Peter Barrett
 /*
+** Permission to use, copy, modify, and/or distribute this software for
+** any purpose with or without fee is hereby granted, provided that the
+** above copyright notice and this permission notice appear in all copies.
+**
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+** SOFTWARE.
+  Copyright (c) 2015 Arduino LLC.  All right reserved.
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
+#include <Arduino.h>
+#include "SAMD21_USBDevice.h"
+#include "USB_host.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdint.h>
+//#include "../Arduino.h"
+#include "sam.h"
+#include "wiring_constants.h"
+#include "USBCore.h"
+#include "USB/USB_device.h"   // needed for USB PID define
+#include "USBDesc.h"
+#include "USBAPI.h"
+#define TRACE_CORE(x)
+//==================================================================
+/*
+#if (defined CDC_ENABLED) && defined(HID_ENABLED)
+//#define USB_PID_ZERO       0x004B  // CDC and HID
+#define USB_PID_ZERO       0x804d  // CDC only
+#else
+#if (defined CDC_ENABLED)
+#define USB_PID_ZERO       0x804d  // CDC only  usbserial.name
+#else
+#define USB_PID_ZERO       0x804d  // HID only
+#endif
+#endif
+*/
+#define USB_PID_ZERO_PRO        0x804d
+// USB Device
+//#define USB_VID                       0x2a03 // arduino srl vid
+//#undef USB_PID
+//#define USB_PID            USB_PID_ZERO
+//==================================================================
+#include <limits.h>
+USBDevice_SAMD21G18x usbd;
 static char isRemoteWakeUpEnabled = 0;
 static char isEndpointHalt = 0;
+extern void (*gpf_isr)(void);
 …
 };
+#define USB_PID_ZERO_PRO        0x804d
+#define USB_PRODUCT "Arduino M0 Pro"
 #ifndef USB_PRODUCT
 // Use a hardcoded product name if none is provided
 …
-//      DEVICE DESCRIPTOR
 #if (defined CDC_ENABLED) && defined(HID_ENABLED)
 const DeviceDescriptor USB_DeviceDescriptor =
 …
 #endif
 //==================================================================
 volatile uint32_t _usbConfiguration = 0;
-volatile uint32_t _usbInitialized = 0;
 volatile uint32_t _usbSetInterface = 0;
+static __attribute__((__aligned__(4))) //__attribute__((__section__(".bss_hram0")))
+uint8_t udd_ep_out_cache_buffer[7][64];
+static __attribute__((__aligned__(4))) //__attribute__((__section__(".bss_hram0")))
+uint8_t udd_ep_in_cache_buffer[7][64];
 //==================================================================
+//      Number of bytes, assumes a rx endpoint
+uint32_t USBD_Available(uint32_t ep)
+{
+        return UDD_FifoByteCount(ep);
+}
+//      Non Blocking receive
+//      Return number of bytes read
+uint32_t USBD_Recv(uint32_t ep, void* d, uint32_t len)
+{
+        if (!_usbConfiguration || len < 0)
+bool _dry_run = false;
+bool _pack_message = false;
+uint16_t _pack_size = 0;
+uint8_t _pack_buffer[256];
+void packMessages(bool val)
+{
+        if (val) {
+                _pack_message = true;
+                _pack_size = 0;
+        } else {
+                _pack_message = false;
+                USBD_SendControl(_pack_buffer, _pack_size);
+        }
+}
+// Blocking Send of data to an endpoint
+uint32_t USBD_Send(uint32_t ep, const void *data, uint32_t len)
+{
+        uint32_t length = 0;
+        if (!_usbConfiguration)
                 return -1;
+        uint32_t n = UDD_FifoByteCount(ep);
+        len = min(n,len);
+        n = len;
+        uint8_t* dst = (uint8_t*)d;
+        while (n--)
+                *dst++ = UDD_Recv8(ep);
+        if (len && !UDD_FifoByteCount(ep)) // release empty buffer
+                UDD_ReleaseRX(ep);
+  //----- Tx & Rx led blinking during transmission ----- begin ----
+        PORT->Group[1].OUTTGL.reg =0x00000008 ;  //RxLED
+        for(int i=0; i < 100000; i++)
+        {
+                asm("NOP");
+        }
+        PORT->Group[1].OUTTGL.reg =0x00000008 ;
+  //----- Tx & Rx led blinking during transmission ----- end ----
+        if (len > 16384)
+                return -1;
+        PORT->Group[0].OUTCLR.reg =0x08000000 ; //TxLED on
+        // Flash area
+        while (len != 0)
+        {
+                if (len >= 64) {
+                        length = 64;
+                } else {
+                        length = len;
+                }
+                /* memcopy could be safer in multi threaded environment */
+                memcpy(&udd_ep_in_cache_buffer[ep], data, length);
+                usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+                usbd.epBank1SetByteCount(ep, length);
+                // Clear the transfer complete flag
+                usbd.epBank1AckTransferComplete(ep);
+                // RAM buffer is full, we can send data (IN)
+                usbd.epBank1SetReady(ep);
+                // Wait for transfer to complete
+                while (!usbd.epBank1IsTransferComplete(ep)) {
+                        ;  // need fire exit.
+                }
+                len -= length;
+                data = (char *)data + length;
+        }
         return len;
+}
+//      Recv 1 byte if ready
+uint32_t USBD_Recv(uint32_t ep)
+{
+        uint8_t c;
+        if (USBD_Recv(ep, &c, 1) != 1)
+                return -1;
+        else
+                return c;
+}
+//      Blocking Send of data to an endpoint
+uint32_t USBD_Send(uint32_t ep, const void* d, uint32_t len)
+{
+        int r = len;
+        const uint8_t* data = (const uint8_t*)d;
+    if (!_usbConfiguration)
+    {
+        TRACE_CORE(printf("pb conf\n\r");)
+                return -1;
+    }
+        UDD_Send(ep, data, len);
+        /* Clear the transfer complete flag  */
+        udd_clear_transf_cplt(ep);
+        /* Set the bank as ready */
+        udd_bk_rdy(ep);
+        /* Wait for transfer to complete */
+        while (! udd_is_transf_cplt(ep));  // need fire exit.
+  //----- Tx & Rx led blinking during transmission ----- begin ----
+        PORT->Group[0].OUTTGL.reg =0x08000000 ; //TxLED
+        for(int i=0; i < 100000; i++)
+        {
+                asm("NOP");
+        }
+        PORT->Group[0].OUTTGL.reg =0x08000000 ;
+        /*for(int i=0; i < 100000; i++)
+        {
+                asm("NOP");
+        }*/
+  //----- Tx & Rx led blinking during transmission ----- end ----
+        return r;
+}
+uint32_t USBD_SendControl(uint8_t flags, const void* d, uint32_t len)
+{
+        const uint8_t* data = (const uint8_t*)d;
+uint32_t USBD_armSend(uint32_t ep, const void* data, uint32_t len)
+{
+        memcpy(&udd_ep_in_cache_buffer[ep], data, len);
+        // Get endpoint configuration from setting register
+        usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+        usbd.epBank1SetMultiPacketSize(ep, 0);
+        usbd.epBank1SetByteCount(ep, len);
+        return len;
+}
+uint32_t USBD_SendControl(const void* _data, uint32_t len)
+{
+        const uint8_t *data = reinterpret_cast<const uint8_t *>(_data);
         uint32_t length = len;
         uint32_t sent = 0;
         uint32_t pos = 0;
+        TRACE_CORE(printf("=> USBD_SendControl TOTAL len=%lu\r\n", len);)
+                while (len > 0)
+                {
+                        sent = UDD_Send(EP0, data + pos, len);
+                        TRACE_CORE(printf("=> USBD_SendControl sent=%lu\r\n", sent);)
+                        pos += sent;
+                        len -= sent;
+                }
+        if (_dry_run == true)
+                return length;
+        if (_pack_message == true) {
+                memcpy(&_pack_buffer[_pack_size], data, len);
+                _pack_size += len;
+                return length;
+        }
+        while (len > 0)
+        {
+                sent = USBD_armSend(EP0, data + pos, len);
+                pos += sent;
+                len -= sent;
+        }
         return length;
+}
+// Send a USB descriptor string. The string is stored as a
+// plain ASCII string but is sent out as UTF-16 with the
+// correct 2-byte prefix
+static bool USB_SendStringDescriptor(const uint8_t *string, int wLength)
+{
         uint16_t buff[64];
+bool USBD_SendStringDescriptor(const uint8_t *string, uint8_t maxlen)
+{
+        if (maxlen < 2)
+                return false;
+        uint16_t buff[maxlen/2];
         int l = 1;
         wLength -= 2;
         while (*string && wLength>0)
+        maxlen -= 2;
+        while (*string && maxlen>0)
+        {
                 buff[l++] = (uint8_t)(*string++);
                 wLength -= 2;
+                maxlen -= 2;
+        }
         buff[0] = (3<<8) | (l*2);
+        return USBD_SendControl(0, (uint8_t*)buff, l*2);
+}
+uint32_t USBD_RecvControl(void* d, uint32_t len)
+{
+        udd_ack_out_received(0);
+        return len;
+}
+//      Handle CLASS_INTERFACE requests
+bool USBD_ClassInterfaceRequest(Setup& setup)
+{
+        uint8_t i = setup.wIndex;
+        TRACE_CORE(printf("=> USBD_ClassInterfaceRequest\r\n");)
+#ifdef CDC_ENABLED
+        if (CDC_ACM_INTERFACE == i)
+        {
+                if( CDC_Setup(setup) == false )
+                {
+                        send_zlp();
+                }
+        return USBD_SendControl((uint8_t*)buff, l*2);
+}
+uint8_t USBD_SendInterfaces(uint32_t* total)
+{
+        uint8_t interfaces = 0;
+#if defined(CDC_ENABLED)
+        total[0] += CDC_GetInterface(&interfaces);
+#endif
+        return interfaces;
+}
+// Construct a dynamic configuration descriptor
+// This really needs dynamic endpoint allocation etc
+uint32_t USBD_SendConfiguration(uint32_t maxlen)
+{
+        uint32_t total = 0;
+        // Count and measure interfaces
+        _dry_run = true;
+        uint8_t interfaces = USBD_SendInterfaces(&total);
+        _Pragma("pack(1)")
+        ConfigDescriptor config = D_CONFIG((uint16_t)(total + sizeof(ConfigDescriptor)), interfaces);
+        _Pragma("pack()")
+        //      Now send them
+        _dry_run = false;
+        if (maxlen == sizeof(ConfigDescriptor)) {
+                USBD_SendControl(&config, sizeof(ConfigDescriptor));
                 return true;
+        }
+#endif
+#ifdef HID_ENABLED
+        if (HID_INTERFACE == i)
+        {
+                if( HID_Setup(setup) == true )
+                {
+                        send_zlp();
+                }
+                return true;
+        }
+#endif
+        return false;
+}
+//      Construct a dynamic configuration descriptor
+//      This really needs dynamic endpoint allocation etc
+//      TODO
+static bool USBD_SendConfiguration(uint32_t maxlen)
+{
+        uint8_t cache_buffer[128];
+        uint8_t i;
+        const uint8_t* interfaces;
+        uint32_t interfaces_length = 0;
+        uint8_t num_interfaces[1];
+        num_interfaces[0] = 0;
+#if (defined CDC_ENABLED) && defined(HID_ENABLED)
+    num_interfaces[0] += 3;
+    interfaces = (const uint8_t*) CDC_GetInterface();
+    interfaces_length = CDC_GetInterfaceLength() + HID_GetInterfaceLength();
+    if( maxlen > CDC_GetInterfaceLength() + HID_GetInterfaceLength() + sizeof(ConfigDescriptor) )
+    {
+            maxlen = CDC_GetInterfaceLength() + HID_GetInterfaceLength() + sizeof(ConfigDescriptor);
+    }
+#else
+#ifdef CDC_ENABLED
+    num_interfaces[0] += 2;
+        interfaces = (const uint8_t*) CDC_GetInterface();
+        interfaces_length += CDC_GetInterfaceLength();
+        if( maxlen > CDC_GetInterfaceLength()+ sizeof(ConfigDescriptor) )
+        {
+                maxlen = CDC_GetInterfaceLength()+ sizeof(ConfigDescriptor);
+        }
+#endif
+#ifdef HID_ENABLED
+    num_interfaces[0] += 1;
+        interfaces = (const uint8_t*) HID_GetInterface();
+        interfaces_length += HID_GetInterfaceLength();
+        if( maxlen > HID_GetInterfaceLength()+ sizeof(ConfigDescriptor) )
+        {
+                maxlen = HID_GetInterfaceLength()+ sizeof(ConfigDescriptor);
+        }
+#endif
+#endif
+_Pragma("pack(1)")
+        ConfigDescriptor config = D_CONFIG((uint16_t)(interfaces_length + sizeof(ConfigDescriptor)),num_interfaces[0]);
+_Pragma("pack()")
+        memcpy( cache_buffer, &config, sizeof(ConfigDescriptor) );
+#if (defined CDC_ENABLED) && defined(HID_ENABLED)
+        for ( i=0; i<CDC_GetInterfaceLength(); i++)
+        {
+                cache_buffer[i+sizeof(ConfigDescriptor)] = interfaces[i];
+        }
+        interfaces = (const uint8_t*) HID_GetInterface();
+        for ( i=0; i<HID_GetInterfaceLength(); i++)
+        {
+                cache_buffer[i+sizeof(ConfigDescriptor)+CDC_GetInterfaceLength()] = interfaces[i];
+        }
+#else
+#ifdef HID_ENABLED
+        for ( i=0; i<interfaces_length; i++)
+        {
+                cache_buffer[i+sizeof(ConfigDescriptor)] = interfaces[i];
+        }
+#endif
+#ifdef CDC_ENABLED
+        for ( i=0; i<interfaces_length; i++)
+        {
+                cache_buffer[i+sizeof(ConfigDescriptor)] = interfaces[i];
+        }
+#endif
+#endif
+        if (maxlen > sizeof(cache_buffer))
+        {
+                 maxlen = sizeof(cache_buffer);
+        }
+        USBD_SendControl(0,cache_buffer, maxlen );
+        total = 0;
+        packMessages(true);
+        USBD_SendControl(&config, sizeof(ConfigDescriptor));
+        USBD_SendInterfaces(&total);
+        packMessages(false);
         return true;
+}
 static bool USBD_SendDescriptor(Setup* pSetup)
+{
         uint8_t t = pSetup->wValueH;
+bool USBD_SendDescriptor(Setup &setup)
+{
+        uint8_t t = setup.wValueH;
         uint8_t desc_length = 0;
+        const uint8_t* desc_addr = 0;
+        if (USB_CONFIGURATION_DESCRIPTOR_TYPE == t)
+        {
+                TRACE_CORE(printf("=> USBD_SendDescriptor : USB_CONFIGURATION_DESCRIPTOR_TYPE length=%d\r\n", setup.wLength);)
+                return USBD_SendConfiguration(pSetup->wLength);
+        }
+#ifdef HID_ENABLED
+        if (HID_REPORT_DESCRIPTOR_TYPE == t)
+        {
+                TRACE_CORE(puts("=> USBD_SendDescriptor : HID_REPORT_DESCRIPTOR_TYPE\r\n");)
+                return HID_GetDescriptor();
+        }
+        if (HID_HID_DESCRIPTOR_TYPE == t)
+        {
+                uint8_t tab[9] = D_HIDREPORT((uint8_t)HID_SizeReportDescriptor());
+                TRACE_CORE(puts("=> USBD_SendDescriptor : HID_HID_DESCRIPTOR_TYPE\r\n");)
+                return USBD_SendControl(0, tab, sizeof(tab));
+        }
+#endif
+        if (USB_DEVICE_DESCRIPTOR_TYPE == t)
+        {
+                TRACE_CORE(puts("=> USBD_SendDescriptor : USB_DEVICE_DESCRIPTOR_TYPE\r\n");)
+                desc_addr = (const uint8_t*)&USB_DeviceDescriptor;
+        if( *desc_addr > pSetup->wLength ) {
+            desc_length = pSetup->wLength;
+        }
+        bool _cdcComposite;
+        int ret;
+        const uint8_t *desc_addr = 0;
+        if (t == USB_CONFIGURATION_DESCRIPTOR_TYPE)
+        {
+                return USBD_SendConfiguration(setup.wLength);
+        }
+        if (t == USB_DEVICE_DESCRIPTOR_TYPE)
+        {
+                if (setup.wLength == 8)
+                        _cdcComposite = 1;
+                desc_addr = _cdcComposite ?  (const uint8_t*)&USB_DeviceDescriptor : (const uint8_t*)&USB_DeviceDescriptor;
+                if (*desc_addr > setup.wLength) {
+                        desc_length = setup.wLength;
+                }
+        }
         else if (USB_STRING_DESCRIPTOR_TYPE == t)
+        {
+                TRACE_CORE(puts("=> USBD_SendDescriptor : USB_STRING_DESCRIPTOR_TYPE\r\n");)
+                if (pSetup->wValueL == 0) {
+                if (setup.wValueL == 0) {
                         desc_addr = (const uint8_t*)&STRING_LANGUAGE;
+                }
                 else if (pSetup->wValueL == IPRODUCT) {
                         return USB_SendStringDescriptor(STRING_PRODUCT, pSetup->wLength);
+                }
                 else if (pSetup->wValueL == IMANUFACTURER) {
                         return USB_SendStringDescriptor(STRING_MANUFACTURER, pSetup->wLength);
+                else if (setup.wValueL == IPRODUCT) {
+                        return USBD_SendStringDescriptor(STRING_PRODUCT, setup.wLength);
+                }
+                else if (setup.wValueL == IMANUFACTURER) {
+                        return USBD_SendStringDescriptor(STRING_MANUFACTURER, setup.wLength);
+                }
                 else {
                         return false;
+                }
+                if( *desc_addr > pSetup->wLength ) {
+                        desc_length = pSetup->wLength;
+                }
+        }
+    else
+    {
+        TRACE_CORE(printf("Device ERROR");)
+    }
+        if (desc_addr == 0)
+        {
+                if (*desc_addr > setup.wLength) {
+                        desc_length = setup.wLength;
+                }
+        }
+        else
+        {
+        }
+        if (desc_addr == 0) {
                 return false;
+        }
+        if (desc_length == 0)
+        {
+        if (desc_length == 0) {
                 desc_length = *desc_addr;
+        }
+        TRACE_CORE(printf("=> USBD_SendDescriptor : desc_addr=%p desc_length=%d\r\n", desc_addr, desc_length);)
+        USBD_SendControl(0, desc_addr, desc_length);
+        USBD_SendControl(desc_addr, desc_length);
         return true;
+}
+void EndpointHandler(uint8_t bEndpoint)
+{
+void initEP(uint32_t ep, uint32_t config)
+{
+        if (config == (USB_ENDPOINT_TYPE_INTERRUPT | USB_ENDPOINT_IN(0)))
+        {
+                usbd.epBank1SetSize(ep, 64);
+                usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+                usbd.epBank1SetType(ep, 4); // INTERRUPT IN
+        }
+        else if (config == (USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_OUT(0)))
+        {
+                usbd.epBank0SetSize(ep, 64);
+                usbd.epBank0SetAddress(ep, &udd_ep_out_cache_buffer[ep]);
+                usbd.epBank0SetType(ep, 3); // BULK OUT
+                // Release OUT EP
+                usbd.epBank0SetMultiPacketSize(ep, 64);
+                usbd.epBank0SetByteCount(ep, 0);
+        }
+        else if (config == (USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_IN(0)))
+        {
+                usbd.epBank1SetSize(ep, 64);
+                usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[ep]);
+                // NAK on endpoint IN, the bank is not yet filled in.
+                usbd.epBank1ResetReady(ep);
+                usbd.epBank1SetType(ep, 3); // BULK IN
+        }
+        else if (config == USB_ENDPOINT_TYPE_CONTROL)
+        {
+                // XXX: Needed?
+//              usbd.epBank0DisableAutoZLP(ep);
+//              usbd.epBank1DisableAutoZLP(ep);
+                // Setup Control OUT
+                usbd.epBank0SetSize(ep, 64);
+                usbd.epBank0SetAddress(ep, &udd_ep_out_cache_buffer[ep]);
+                usbd.epBank0SetType(ep, 1); // CONTROL OUT / SETUP
+                // Setup Control IN
+                usbd.epBank1SetSize(ep, 64);
+                usbd.epBank1SetAddress(ep, &udd_ep_in_cache_buffer[0]);
+                usbd.epBank1SetType(ep, 1); // CONTROL IN
+                // Release OUT EP
+                usbd.epBank0SetMultiPacketSize(ep, 64);
+                usbd.epBank0SetByteCount(ep, 0);
+                // NAK on endpoint OUT, the bank is full.
+                usbd.epBank0SetReady(ep);
+        }
+}
+void sendZlp(uint32_t ep)
+{
+        // Set the byte count as zero
+        usbd.epBank1SetByteCount(ep, 0);
+}
+void setAddress(uint32_t addr)
+{
+        usbd.epBank1SetByteCount(0, 0);
+        usbd.epBank1AckTransferComplete(0);
+        // RAM buffer is full, we can send data (IN)
+        usbd.epBank1SetReady(0);
+        // Wait for transfer to complete
+        while (!usbd.epBank1IsTransferComplete(0)) {}
+        // Set USB address to addr
+        USB->DEVICE.DADD.bit.DADD = addr; // Address
+        USB->DEVICE.DADD.bit.ADDEN = 1; // Enable
+}
+uint32_t EndPoints[] =
+{
+        USB_ENDPOINT_TYPE_CONTROL,
 #ifdef CDC_ENABLED
+        if( bEndpoint == CDC_ENDPOINT_OUT )
+        {
+                udd_ack_out_received(CDC_ENDPOINT_OUT);
+                // Handle received bytes
+        USB_ENDPOINT_TYPE_INTERRUPT | USB_ENDPOINT_IN(0),           // CDC_ENDPOINT_ACM
+        USB_ENDPOINT_TYPE_BULK      | USB_ENDPOINT_OUT(0),               // CDC_ENDPOINT_OUT
+        USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_IN(0),                // CDC_ENDPOINT_IN
+#endif
+};
+void initEndpoints() {
+        for (uint8_t i = 1; i < sizeof(EndPoints) && EndPoints[i] != 0; i++) {
+                initEP(i, EndPoints[i]);
+        }
+}
+bool handleStandardSetup(Setup &setup)
+{
+        switch (setup.bRequest) {
+        case GET_STATUS:
+                if (setup.bmRequestType == 0)  // device
+                {
+                        // Send the device status
+                        // TODO: Check current configuration for power mode (if device is configured)
+                        // TODO: Check if remote wake-up is enabled
+                        uint8_t buff[] = { 0, 0 };
+                        USBD_armSend(0, buff, 2);
+                        return true;
+                }
+                // if( setup.bmRequestType == 2 ) // Endpoint:
+                else
+                {
+                        // Send the endpoint status
+                        // Check if the endpoint if currently halted
+                        uint8_t buff[] = { 0, 0 };
+                        if (isEndpointHalt == 1)
+                                buff[0] = 1;
+                        USBD_armSend(0, buff, 2);
+                        return true;
+                }
+        case CLEAR_FEATURE:
+                // Check which is the selected feature
+                if (setup.wValueL == 1) // DEVICEREMOTEWAKEUP
+                {
+                        // Enable remote wake-up and send a ZLP
+                        uint8_t buff[] = { 0, 0 };
+                        if (isRemoteWakeUpEnabled == 1)
+                                buff[0] = 1;
+                        USBD_armSend(0, buff, 2);
+                        return true;
+                }
+                else // if( setup.wValueL == 0) // ENDPOINTHALT
+                {
+                        isEndpointHalt = 0;
+                        sendZlp(0);
+                        return true;
+                }
+        case SET_FEATURE:
+                // Check which is the selected feature
+                if (setup.wValueL == 1) // DEVICEREMOTEWAKEUP
+                {
+                        // Enable remote wake-up and send a ZLP
+                        isRemoteWakeUpEnabled = 1;
+                        uint8_t buff[] = { 0 };
+                        USBD_armSend(0, buff, 1);
+                        return true;
+                }
+                if (setup.wValueL == 0) // ENDPOINTHALT
+                {
+                        // Halt endpoint
+                        isEndpointHalt = 1;
+                        sendZlp(0);
+                        return true;
+                }
+        case SET_ADDRESS:
+                setAddress(setup.wValueL);
+                return true;
+        case GET_DESCRIPTOR:
+                return USBD_SendDescriptor(setup);
+        case SET_DESCRIPTOR:
+                return false;
+        case GET_CONFIGURATION:
+                USBD_armSend(0, (void*)&_usbConfiguration, 1);
+                return true;
+        case SET_CONFIGURATION:
+                if (REQUEST_DEVICE == (setup.bmRequestType & REQUEST_RECIPIENT)) {
+                        initEndpoints();
+                        _usbConfiguration = setup.wValueL;
+                        #if defined(CDC_ENABLED)
+                        // Enable interrupt for CDC reception from host (OUT packet)
+                        usbd.epBank1EnableTransferComplete(CDC_ENDPOINT_ACM);
+                        usbd.epBank0EnableTransferComplete(CDC_ENDPOINT_OUT);
+                        #endif
+                        sendZlp(0);
+                        return true;
+                } else {
+                        return false;
+                }
+        case GET_INTERFACE:
+                USBD_armSend(0, (void*)&_usbSetInterface, 1);
+                return true;
+        case SET_INTERFACE:
+                _usbSetInterface = setup.wValueL;
+                sendZlp(0);
+                return true;
+        default:
+                return true;
+        }
+}
+bool handleClassInterfaceSetup(Setup& setup)
+{
+        uint8_t i = setup.wIndex;
+        #if defined(CDC_ENABLED)
+        if (CDC_ACM_INTERFACE == i)
+        {
+                if (CDC_Setup(setup) == false) {
+                        sendZlp(0);
+                }
+                return true;
+        }
+        #endif
+        return false;
+}
+void stall(uint32_t ep)
+{
+        // TODO: test
+        // TODO: use .bit. notation
+        // Stall endpoint
+        USB->DEVICE.DeviceEndpoint[ep].EPSTATUSSET.reg = USB_DEVICE_EPSTATUSSET_STALLRQ(2);
+}
+void handleEndpoint(uint8_t ep)
+{
+#if defined(CDC_ENABLED)
+        if (ep == CDC_ENDPOINT_OUT)
+        {
+                // The RAM Buffer is empty: we can receive data
+                //usbd.epBank0ResetReady(CDC_ENDPOINT_OUT);
+                // Handle received bytes
                 if (USBD_Available(CDC_ENDPOINT_OUT))
+                        SerialUSB.accept();
+        }
+        if (ep == CDC_ENDPOINT_IN)
+        {
+                // NAK on endpoint IN, the bank is not yet filled in.
+                usbd.epBank1ResetReady(CDC_ENDPOINT_IN);
+                usbd.epBank1AckTransferComplete(CDC_ENDPOINT_IN);
+        }
+        if (ep == CDC_ENDPOINT_ACM)
+        {
+                // NAK on endpoint IN, the bank is not yet filled in.
+                usbd.epBank1ResetReady(CDC_ENDPOINT_ACM);
+                usbd.epBank1AckTransferComplete(CDC_ENDPOINT_ACM);
+        }
+#endif
+}
+void ISRHandler()
+{
+        if (_pack_message == true) {
+                return;
+        }
+        // End-Of-Reset
+        if (usbd.isEndOfResetInterrupt())
+        {
+                // Configure EP 0
+                initEP(0, USB_ENDPOINT_TYPE_CONTROL);
+                // Enable Setup-Received interrupt
+                usbd.epBank0EnableSetupReceived(0);
+                _usbConfiguration = 0;
+                usbd.ackEndOfResetInterrupt();
+        }
+        // Start-Of-Frame
+        if (usbd.isStartOfFrameInterrupt())
+        {
+                usbd.ackStartOfFrameInterrupt();
+        }
+        // Endpoint 0 Received Setup interrupt
+        if (usbd.epBank0IsSetupReceived(0))
+        {
+                usbd.epBank0AckSetupReceived(0);
+                Setup *setup = reinterpret_cast<Setup *>(udd_ep_out_cache_buffer[0]);
+                /* Clear the Bank 0 ready flag on Control OUT */
+                // The RAM Buffer is empty: we can receive data
+                usbd.epBank0ResetReady(0);
+                bool ok;
+                if (REQUEST_STANDARD == (setup->bmRequestType & REQUEST_TYPE)) {
+                        // Standard Requests
+                        ok = handleStandardSetup(*setup);
+                } else {
+                        // Class Interface Requests
+                        ok = handleClassInterfaceSetup(*setup);
+                }
+                if (ok) {
+                        usbd.epBank1SetReady(0);
+                } else {
+                        stall(0);
+                }
+                if (usbd.epBank1IsStalled(0))
+                {
+                        SerialUSB.accept();
+                }
+        }
+        if( bEndpoint == CDC_ENDPOINT_IN )
+        {
+                udd_ack_in_received(CDC_ENDPOINT_IN);
+                /* Clear the transfer complete flag  */
+                udd_clear_transf_cplt(CDC_ENDPOINT_IN);
+        }
+        if( bEndpoint == CDC_ENDPOINT_ACM )
+        {
+                udd_ack_in_received(CDC_ENDPOINT_ACM);
+                /* Clear the transfer complete flag  */
+                udd_clear_transf_cplt(CDC_ENDPOINT_ACM);
+        }
+#endif
+#ifdef HID_ENABLED
+        /* Nothing to do in our example */
+#endif
+}
+void USB_Handler(void)
+{
+        uint16_t flags;
+        uint8_t i;
+        uint8_t ept_int;
+        ept_int = udd_endpoint_interrupt();
+                        usbd.epBank1AckStalled(0);
+                        // Remove stall request
+                        usbd.epBank1DisableStalled(0);
+                }
+        /* Not endpoint interrupt */
+        if (0 == ept_int)
+        {
+                udd_clear_wakeup_interrupt();
+                udd_clear_eorsm_interrupt();
+                udd_clear_suspend_interrupt();
+                // End of bus reset
+                if (Is_udd_reset())
+        } // end Received Setup handler
+        PORT->Group[0].OUTSET.reg =0x08000000 ; //TxLED off
+        PORT->Group[1].OUTSET.reg =0x00000008 ; //RxLED off
+        uint8_t i=0;
+        uint8_t ept_int = usbd.epInterruptSummary() & 0xFE; // Remove endpoint number 0 (setup)
+        while (ept_int != 0)
+        {
+                // Check if endpoint has a pending interrupt
+                if ((ept_int & (1 << i)) != 0)
+                {
+                        TRACE_CORE(printf(">>> End of Reset\r\n");)
+                        // Reset USB address to 0
+                        udd_configure_address(0);
+                        // Configure EP 0
+                        UDD_InitEP(0, USB_ENDPOINT_TYPE_CONTROL);
+                        udd_enable_setup_received_interrupt(0);
+                        _usbConfiguration = 0;
+                        udd_ack_reset();
+                }
+                if (Is_udd_sof())
+                {
+                        udd_ack_sof();
+                }
+        }
+        else
+        {
+                // Endpoint interrupt
+                flags = udd_read_endpoint_flag(0);
+                // endpoint received setup interrupt
+                if (flags & USB_DEVICE_EPINTFLAG_RXSTP)
+                {
+                        Setup *pSetupData;
+                        /* Clear the Received Setup flag */
+                        udd_read_endpoint_flag(0) = USB_DEVICE_EPINTFLAG_RXSTP;
+                        UDD_Recv(EP0, (uint8_t**)&pSetupData);
+                        /* Clear the Bank 0 ready flag on Control OUT */
+                        udd_ack_out_received(0);
+                        bool ok = true;
+                        if (REQUEST_STANDARD == (pSetupData->bmRequestType & REQUEST_TYPE))
+                        // Endpoint Transfer Complete (0/1) Interrupt
+                        if (usbd.epBank0IsTransferComplete(i) ||
+                            usbd.epBank1IsTransferComplete(i))
+                        {
+                                unsigned char data_to_be_send[2];
+                                // Standard Requests
+                                uint8_t r = pSetupData->bRequest;
+                                if (GET_STATUS == r)
+                                {
+                                        if( pSetupData->bmRequestType == 0 )  // device
+                                        {
+                                                // Send the device status
+                                        TRACE_CORE(puts(">>> EP0 Int: GET_STATUS\r\n");)
+                                                // Check current configuration for power mode (if device is configured)
+                                                // Check if remote wake-up is enabled
+                                                data_to_be_send[0]=0;
+                                                data_to_be_send[1]=0;
+                                                UDD_Send(0, data_to_be_send, 2);
+                                        }
+                                        // if( pSetupData->bmRequestType == 2 ) // Endpoint:
+                                        else
+                                        {
+                                                // Send the endpoint status
+                                                // Check if the endpoint if currently halted
+                                                if( isEndpointHalt == 1 )
+                                                        data_to_be_send[0]=1;
+                                                else
+                                                        data_to_be_send[0]=0;
+                                                data_to_be_send[1]=0;
+                                                UDD_Send(0, data_to_be_send, 2);
+                                        }
+                                }
+                                else if (CLEAR_FEATURE == r)
+                                {
+                                   // Check which is the selected feature
+                                        if( pSetupData->wValueL == 1) // DEVICEREMOTEWAKEUP
+                                        {
+                                                // Enable remote wake-up and send a ZLP
+                                                if( isRemoteWakeUpEnabled == 1 )
+                                                        data_to_be_send[0]=1;
+                                                else
+                                                        data_to_be_send[0]=0;
+                                                data_to_be_send[1]=0;
+                                                UDD_Send(0, data_to_be_send, 2);
+                                        }
+                                        else // if( pSetupData->wValueL == 0) // ENDPOINTHALT
+                                        {
+                                                isEndpointHalt = 0;
+                                                send_zlp();
+                                        }
+                                }
+                                else if (SET_FEATURE == r)
+                                {
+                                        // Check which is the selected feature
+                                        if( pSetupData->wValueL == 1) // DEVICEREMOTEWAKEUP
+                                        {
+                                                // Enable remote wake-up and send a ZLP
+                                                isRemoteWakeUpEnabled = 1;
+                                        data_to_be_send[0] = 0;
+                                                UDD_Send(0, data_to_be_send, 1);
+                                        }
+                                        if( pSetupData->wValueL == 0) // ENDPOINTHALT
+                                        {
+                                                // Halt endpoint
+                                                isEndpointHalt = 1;
+                                                send_zlp();
+                                        }
+                                }
+                                else if (SET_ADDRESS == r)
+                                {
+                                        TRACE_CORE(puts(">>> EP0 Int: SET_ADDRESS\r\n");)
+                                        UDD_SetAddress(pSetupData->wValueL);
+                                }
+                                else if (GET_DESCRIPTOR == r)
+                                {
+                                        TRACE_CORE(puts(">>> EP0 Int: GET_DESCRIPTOR\r\n");)
+                                        ok = USBD_SendDescriptor(pSetupData);
+                                }
+                                else if (SET_DESCRIPTOR == r)
+                                {
+                                        TRACE_CORE(puts(">>> EP0 Int: SET_DESCRIPTOR\r\n");)
+                                        ok = false;
+                                }
+                                else if (GET_CONFIGURATION == r)
+                                {
+                                        TRACE_CORE(puts(">>> EP0 Int: GET_CONFIGURATION\r\n");)
+                                        UDD_Send(0, (void*)&_usbConfiguration, 1);
+                                }
+                                else if (SET_CONFIGURATION == r)
+                                {
+                                        if (REQUEST_DEVICE == (pSetupData->bmRequestType & REQUEST_RECIPIENT))
+                                        {
+                                                TRACE_CORE(printf(">>> EP0 Int: SET_CONFIGURATION REQUEST_DEVICE %d\r\n", pSetupData->wValueL);)
+#ifdef HID_ENABLED
+                                                UDD_InitEP( HID_ENDPOINT_INT, USB_ENDPOINT_TYPE_INTERRUPT | USB_ENDPOINT_IN(0));
+#endif
+#ifdef CDC_ENABLED
+                                                UDD_InitEP( CDC_ENDPOINT_ACM, USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_IN(0));
+                                                UDD_InitEP( CDC_ENDPOINT_OUT, USB_ENDPOINT_TYPE_BULK | USB_ENDPOINT_OUT(0));
+                                                UDD_InitEP( CDC_ENDPOINT_IN, USB_ENDPOINT_TYPE_INTERRUPT | USB_ENDPOINT_IN(0));
+#endif
+                                                _usbConfiguration = pSetupData->wValueL;
+#ifdef CDC_ENABLED
+                                                // Enable interrupt for CDC reception from host (OUT packet)
+                                                udd_ept_enable_it_transf_cplt_in(CDC_ENDPOINT_ACM);
+                                                udd_ept_enable_it_transf_cplt_out(CDC_ENDPOINT_OUT);
+#endif
+                                                send_zlp();
+                                        }
+                                        else
+                                        {
+                                                TRACE_CORE(puts(">>> EP0 Int: SET_CONFIGURATION failed!\r\n");)
+                                                ok = false;
+                                        }
+                                }
+                                else if (GET_INTERFACE == r)
+                                {
+                                        TRACE_CORE(puts(">>> EP0 Int: GET_INTERFACE\r\n");)
+                                        UDD_Send(0, (void*)&_usbSetInterface, 1);
+                                }
+                                else if (SET_INTERFACE == r)
+                                {
+                                        _usbSetInterface = pSetupData->wValueL;
+                                        TRACE_CORE(puts(">>> EP0 Int: SET_INTERFACE\r\n");)
+                                        send_zlp();
+                                }
+                                handleEndpoint(i);
+                        }
+                        else
+                        {
+                                TRACE_CORE(puts(">>> EP0 Int: ClassInterfaceRequest\r\n");)
+                                ok =  USBD_ClassInterfaceRequest(*pSetupData);
+                        }
+                        if (ok)
+                        {
+                                TRACE_CORE(puts(">>> EP0 Int: Send packet\r\n");)
+                                UDD_ClearIN();
+                        }
+                        else
+                        {
+                                TRACE_CORE(puts(">>> EP0 Int: Stall\r\n");)
+                                UDD_Stall(0);
+                        }
+                        if( flags & USB_DEVICE_EPINTFLAG_STALL1 )
+                        {
+                                /* Clear the stall flag */
+                                udd_clear_stall_request(0);
+                                // Remove stall request
+                                udd_remove_stall_request(0);
+                        }
+                }  // end if USB_DEVICE_EPINTFLAG_RXSTP
+                i=0;
+                ept_int &= 0xFE;  // Remove endpoint number 0 (setup)
+                while (ept_int != 0)
+                {
+            // Check if endpoint has a pending interrupt
+            if ((ept_int & (1 << i)) != 0)
+                        {
+                                if( (udd_read_endpoint_flag(i) & USB_DEVICE_EPINTFLAG_TRCPT_Msk ) != 0 )
+                                {
+                                        EndpointHandler(i);
+                                }
+                ept_int &= ~(1 << i);
+                if (ept_int != 0)
+                                {
+                    TRACE_CORE("\n\r  - ");
+                }
+            }
+            i++;
+                        if( i> USB_EPT_NUM) break;  // exit
+        }
+        }
+}
+                        ept_int &= ~(1 << i);
+                }
+                i++;
+                if (i > USB_EPT_NUM)
+                        break;  // fire exit
+        }
+}
+// USB_Handler ISR
+extern "C" void UDD_Handler(void) {
+        ISRHandler();
+}
 void USBD_Flush(uint32_t ep)
+{
+        if (UDD_FifoByteCount(ep))
+        {
+                UDD_ReleaseTX(ep);
+        }
+}
+//      Counting frames
+uint32_t USBD_Connected(void)
+{
+        uint8_t f = UDD_GetFrameNumber();
+        return f != UDD_GetFrameNumber();
+}
+//=======================================================================
+//=======================================================================
+USBDevice_ USBDevice;
+USBDevice_::USBDevice_()
+{
+        if (USBD_Available(ep)) {
+                // RAM buffer is full, we can send data (IN)
+                usbd.epBank1SetReady(ep);
+                // Clear the transfer complete flag
+                usbd.epBank1AckTransferComplete(ep);
+        }
+}
+bool connected()
+{
+        // Count frame numbers
+        uint8_t f = USB->DEVICE.FNUM.bit.FNUM;
+        //delay(3);
+        return f != USB->DEVICE.FNUM.bit.FNUM;
+}
+uint8_t armRecvCtrlOUT(uint32_t ep)
+{
+        // Get endpoint configuration from setting register
+        usbd.epBank0SetAddress(ep, &udd_ep_out_cache_buffer[ep]);
+        usbd.epBank0SetMultiPacketSize(ep, 8);
+        usbd.epBank0SetByteCount(ep, 0);
+        usbd.epBank0ResetReady(ep);
+        // Wait OUT
+        while (!usbd.epBank0IsReady(ep)) {}
+        while (!usbd.epBank0IsTransferComplete(ep)) {}
+        return usbd.epBank0ByteCount(ep);
+}
+uint32_t USBD_RecvControl(void *_data, uint32_t len)
+{
+        uint8_t *data = reinterpret_cast<uint8_t *>(_data);
+        // The RAM Buffer is empty: we can receive data
+        usbd.epBank0ResetReady(0);
+        //usbd.epBank0AckSetupReceived(0);
+        uint32_t read = armRecvCtrlOUT(0);
+        if (read > len)
+                read = len;
+        //while (!usbd.epBank0AckTransferComplete(0)) {}
+        uint8_t *buffer = udd_ep_out_cache_buffer[0];
+        for (uint32_t i=0; i<len; i++) {
+                data[i] = buffer[i];
+        }
+        return read;
+}
+// Number of bytes, assumes a rx endpoint
+uint32_t USBD_Available(uint32_t ep)
+{
+        return usbd.epBank0ByteCount(ep);
+}
+uint8_t armRecv(uint32_t ep)
+{
+        uint16_t count = usbd.epBank0ByteCount(ep);
+        if (count >= 64) {
+                usbd.epBank0SetByteCount(ep, count - 64);
+        } else {
+                usbd.epBank0SetByteCount(ep, 0);
+        }
+        return usbd.epBank0ByteCount(ep);
+}
+// Non Blocking receive
+// Return number of bytes read
+uint32_t USBD_Recv(uint32_t ep, void *_data, uint32_t len)
+{
+        if (!_usbConfiguration)
+                return -1;
+        PORT->Group[1].OUTCLR.reg =0x00000008 ; //RxLED on
+        if (USBD_Available(ep) < len)
+                len = USBD_Available(ep);
+        armRecv(ep);
+        usbd.epBank0DisableTransferComplete(ep);
+        memcpy(_data, udd_ep_out_cache_buffer[ep], len);
+        // release empty buffer
+        if (len && !USBD_Available(ep)) {
+                // The RAM Buffer is empty: we can receive data
+                usbd.epBank0ResetReady(ep);
+                // Clear Transfer complete 0 flag
+                usbd.epBank0AckTransferComplete(ep);
+        }
+        return len;
+}
+// Recv 1 byte if ready
+uint32_t USBD_Recv(uint32_t ep)
+{
+        uint8_t c;
+        if (USBD_Recv(ep, &c, 1) != 1) {
+                return -1;
+        } else {
+                return c;
+        }
+}
+//==================================================================
+void USBDevice_::init()
+{
+        // Enable USB clock
+        PM->APBBMASK.reg |= PM_APBBMASK_USB;
+        // Set up the USB DP/DN pins
+        PORT->Group[0].PINCFG[PIN_PA24G_USB_DM].bit.PMUXEN = 1;
+        PORT->Group[0].PMUX[PIN_PA24G_USB_DM/2].reg &= ~(0xF << (4 * (PIN_PA24G_USB_DM & 0x01u)));
+        PORT->Group[0].PMUX[PIN_PA24G_USB_DM/2].reg |= MUX_PA24G_USB_DM << (4 * (PIN_PA24G_USB_DM & 0x01u));
+        PORT->Group[0].PINCFG[PIN_PA25G_USB_DP].bit.PMUXEN = 1;
+        PORT->Group[0].PMUX[PIN_PA25G_USB_DP/2].reg &= ~(0xF << (4 * (PIN_PA25G_USB_DP & 0x01u)));
+        PORT->Group[0].PMUX[PIN_PA25G_USB_DP/2].reg |= MUX_PA25G_USB_DP << (4 * (PIN_PA25G_USB_DP & 0x01u));
+        // Put Generic Clock Generator 0 as source for Generic Clock Multiplexer 6 (USB reference)
+        GCLK->CLKCTRL.reg = GCLK_CLKCTRL_ID(6)     | // Generic Clock Multiplexer 6
+                            GCLK_CLKCTRL_GEN_GCLK0 | // Generic Clock Generator 0 is source
+                            GCLK_CLKCTRL_CLKEN;
+        while (GCLK->STATUS.bit.SYNCBUSY)
+                ;
+        USB_SetHandler(&UDD_Handler);
+        // Reset USB Device
+        usbd.reset();
+        usbd.calibrate();
+        usbd.setUSBDeviceMode();
+        usbd.runInStandby();
+        usbd.setFullSpeed();
+        // Configure interrupts
+        NVIC_SetPriority((IRQn_Type) USB_IRQn, 0UL);
+        NVIC_EnableIRQ((IRQn_Type) USB_IRQn);
+        usbd.enable();
+        initialized = true;
+}
 bool USBDevice_::attach()
+{
+  if (_usbInitialized != 0UL)
+  {
+    UDD_Attach();
+        if (!initialized)
+                return false;
+        usbd.attach();
+        usbd.enableEndOfResetInterrupt();
+        usbd.enableStartOfFrameInterrupt();
         _usbConfiguration = 0;
         return true;
+  }
+  else
+  {
+    return false;
+  }
+}
+}
 bool USBDevice_::detach()
+{
+        if (_usbInitialized != 0UL)
+        {
+                UDD_Detach();
+                return true;
+        }
+        else
+        {
+        if (!initialized)
                 return false;
+        }
+        usbd.detach();
+        return true;
+}
 bool USBDevice_::configured()
+{
         return _usbConfiguration;
+}
+void USBDevice_::poll()
+{
+}
+void USBDevice_::init()
+{
+        UDD_Init();
+        _usbInitialized=1UL;
+}
+        return _usbConfiguration != 0;
+}
+/*
+ * USB Device instance
+ * -------------------
+ */
+// USBDevice class instance
+USBDevice_ USBDevice;

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USBCore.h

-              r136
+              r224
-// Copyright (c) 2010, Peter Barrett
 /*
+** Permission to use, copy, modify, and/or distribute this software for
+** any purpose with or without fee is hereby granted, provided that the
+** above copyright notice and this permission notice appear in all copies.
+**
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+** SOFTWARE.
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
 #ifndef __USBCORE_H__
 …
 #define SET_INTERFACE                           11
+// bEndpointAddress in Endpoint Descriptor
+#define USB_ENDPOINT_DIRECTION_MASK            0x80
+#define USB_ENDPOINT_OUT(addr)                 ((addr) | 0x00)
+#define USB_ENDPOINT_IN(addr)                  ((addr) | 0x80)
+#define USB_ENDPOINTS                          7
+#define USB_ENDPOINT_TYPE_MASK                 0x03
+#define USB_ENDPOINT_TYPE_CONTROL              0x00
+#define USB_ENDPOINT_TYPE_ISOCHRONOUS          0x01
+#define USB_ENDPOINT_TYPE_BULK                 0x02
+#define USB_ENDPOINT_TYPE_INTERRUPT            0x03
 // bmRequestType
 …
 #define REQUEST_RECIPIENT                       0x1F
+#define REQUEST_DEVICETOHOST_CLASS_INTERFACE  (REQUEST_DEVICETOHOST + REQUEST_CLASS + REQUEST_INTERFACE)
+#define REQUEST_HOSTTODEVICE_CLASS_INTERFACE  (REQUEST_HOSTTODEVICE + REQUEST_CLASS + REQUEST_INTERFACE)
+#define REQUEST_DEVICETOHOST_CLASS_INTERFACE    (REQUEST_DEVICETOHOST | REQUEST_CLASS | REQUEST_INTERFACE)
+#define REQUEST_HOSTTODEVICE_CLASS_INTERFACE    (REQUEST_HOSTTODEVICE | REQUEST_CLASS | REQUEST_INTERFACE)
+#define REQUEST_DEVICETOHOST_STANDARD_INTERFACE (REQUEST_DEVICETOHOST | REQUEST_STANDARD | REQUEST_INTERFACE)
 //      Class requests
 …
 #define CDC_GET_LINE_CODING                     0x21
 #define CDC_SET_CONTROL_LINE_STATE      0x22
+#define CDC_SEND_BREAK                          0x23
 #define MSC_RESET                                       0xFF
 …
 #define MSC_SUBCLASS_SCSI                                               0x06
 #define MSC_PROTOCOL_BULK_ONLY                                  0x50
-#define HID_HID_DESCRIPTOR_TYPE                                 0x21
-#define HID_REPORT_DESCRIPTOR_TYPE                              0x22
-#define HID_PHYSICAL_DESCRIPTOR_TYPE                    0x23
-#define TX_RX_LED_PULSE_MS 100     //----- Tx & Rx led blinking during transmission (declaration)
 _Pragma("pack(1)")
 …
 typedef struct
+{
-#if (defined CDC_ENABLED) && defined(HID_ENABLED)
         //      IAD
         IADDescriptor                           iad;    // Only needed on compound device
-#endif
         //      Control
         InterfaceDescriptor                     cif;
 …
         EndpointDescriptor                      out;
 } MSCDescriptor;
 typedef struct
 …
 #define D_DEVICE(_class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs) \
         { 18, 1, 0x110, _class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs }
+        { 18, 1, 0x200, _class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs }
 /* Table 9-8. Standard Device Descriptor
  * bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
 …
 #define D_CONFIG(_totalLength,_interfaces) \
         { 9, 2, _totalLength,_interfaces, 1, 0, USB_CONFIG_SELF_POWERED, USB_CONFIG_POWER_MA(500) }
+        { 9, 2, _totalLength,_interfaces, 1, 0, USB_CONFIG_BUS_POWERED, USB_CONFIG_POWER_MA(500) }
 /* Table 9-10. Standard Configuration Descriptor
  * bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
  * bmAttributes, bMaxPower */
 #define D_INTERFACE(_n,_numEndpoints,_class,_subClass,_protocol) \
         { 9, 4, _n, 0, _numEndpoints, _class,_subClass, _protocol, 0 }
 …
  * bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
  * bInterfaceSubClass, bInterfaceProtocol, iInterface */
 #define D_ENDPOINT(_addr,_attr,_packetSize, _interval) \
         { 7, 5, _addr,_attr,_packetSize, _interval }
 …
 #define D_IAD(_firstInterface, _count, _class, _subClass, _protocol) \
         { 8, 11, _firstInterface, _count, _class, _subClass, _protocol, 0 }
 /* iadclasscode_r10.pdf, Table 9Z. Standard Interface Association Descriptor
+/* iadclasscode_r10.pdf, Table 9\96Z. Standard Interface Association Descriptor
  * bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass, bFunctionProtocol, iFunction */
 #define D_HIDREPORT(_descriptorLength) \
 …
 /* HID1_11.pdf  E.8 HID Descriptor (Mouse)
  * bLength, bDescriptorType, bcdHID, bCountryCode, bNumDescriptors, bDescriptorType, wItemLength */
 // Functional Descriptor General Format
 #define D_CDCCS(_subtype,_d0,_d1)       { 5, 0x24, _subtype, _d0, _d1 }

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USBDesc.h

-              r136
+              r224
-// Copyright (c) 2010, Peter Barrett
 /*
+** Permission to use, copy, modify, and/or distribute this software for
+** any purpose with or without fee is hereby granted, provided that the
+** above copyright notice and this permission notice appear in all copies.
+**
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+** SOFTWARE.
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+**Modified 04/04/2016 by Arduino.org development team
 */
 …
 #define HID_ENABLED
+#ifdef CDC_ENABLED
+#define CDC_INTERFACE_COUNT 2
+#define CDC_ENPOINT_COUNT 3
+#endif
 // CDC
 #define CDC_ACM_INTERFACE       0       // CDC ACM
 #define CDC_DATA_INTERFACE      1       // CDC Data
+#define CDC_FIRST_ENDPOINT  1
 #define CDC_ENDPOINT_ACM        1
 #define CDC_ENDPOINT_OUT        2
 #define CDC_ENDPOINT_IN         3
+#ifdef CDC_ENABLED
+#define CDC_RX CDC_ENDPOINT_OUT
+#define CDC_TX CDC_ENDPOINT_IN
+#endif
 // HID
 …
 #define HID_ENDPOINT_INT        4
+#define ISERIAL_MAX_LEN        20
 // Defined string description
 #define IMANUFACTURER   1
+#define IPRODUCT                2
+#define IPRODUCT    2
+#define ISERIAL    3
 #endif /* __USBDESC_H__ */

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/USB_host.h

-              r136
+              r224
+/* ----------------------------------------------------------------------------
+ *         SAM Software Package License
+ * ----------------------------------------------------------------------------
+ * Copyright (c) 2011-2012, Atmel Corporation
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following condition is met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the disclaimer below.
+ *
+ * Atmel's name may not be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ----------------------------------------------------------------------------
+ */
+/*
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
 #ifndef USB_HOST_H_INCLUDED
 …
 #include <stdint.h>
+#include "samd21_host.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 #define tokSETUP                UOTGHS_HSTPIPCFG_PTOKEN_SETUP
 #define tokIN                   UOTGHS_HSTPIPCFG_PTOKEN_IN
 #define tokOUT                  UOTGHS_HSTPIPCFG_PTOKEN_OUT
 #define tokINHS                 UOTGHS_HSTPIPCFG_PTOKEN_IN
 #define tokOUTHS                UOTGHS_HSTPIPCFG_PTOKEN_OUT
+#define tokSETUP                USB_HOST_PCFG_PTOKEN_SETUP
+#define tokIN                   USB_HOST_PCFG_PTOKEN_IN
+#define tokOUT                  USB_HOST_PCFG_PTOKEN_OUT
+#define tokINHS                 USB_HOST_PCFG_PTOKEN_IN
+#define tokOUTHS                USB_HOST_PCFG_PTOKEN_OUT
 //! \brief Device speed
 …
 } uhd_vbus_state_t;
-//extern uhd_speed_t uhd_get_speed(void);
-extern void UHD_SetStack(void (*pf_isr)(void));
 extern void UHD_Init(void);
+extern void UHD_BusReset(void);
+extern void UHD_Handler(void);
+extern void USB_SetHandler(void (*pf_isr)(void));
 extern uhd_vbus_state_t UHD_GetVBUSState(void);
 extern uint32_t UHD_Pipe0_Alloc(uint32_t ul_add, uint32_t ul_ep_size);
 extern uint32_t UHD_Pipe_Alloc(uint32_t ul_dev_addr, uint32_t ul_dev_ep, uint32_t ul_type, uint32_t ul_dir, uint32_t ul_maxsize, uint32_t ul_interval, uint32_t ul_nb_bank);
+extern void UHD_Pipe_CountZero(uint32_t ul_pipe);
 extern void UHD_Pipe_Free(uint32_t ul_pipe);
 extern uint32_t UHD_Pipe_Read(uint32_t ul_pipe, uint32_t ul_size, uint8_t* data);

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/samd21_host.c

-              r136
+              r224
+/* ----------------------------------------------------------------------------
+ *         SAM Software Package License
+ * ----------------------------------------------------------------------------
+ * Copyright (c) 2011-2012, Atmel Corporation
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following condition is met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the disclaimer below.
+ *
+ * Atmel's name may not be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ----------------------------------------------------------------------------
+ */
+/*
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+** Modified 04/04/2016 by Arduino.org development team
+*/
 #include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include "../Arduino.h"
+#include "variant.h"
+#include "USB_host.h"
+#include "samd21_host.h"
+#include "sam.h"
+#include "wiring_digital.h"
+#include "wiring_private.h"
+#define HOST_DEFINED
 #ifdef HOST_DEFINED
 …
 #define TRACE_UOTGHS_HOST(x)
-//extern void (*gpf_isr)(void);
 // Handle UOTGHS Host driver state
 static uhd_vbus_state_t uhd_state = UHD_STATE_NO_VBUS;
+ __attribute__((__aligned__(4))) UsbHostDescriptor usb_pipe_table[USB_EPT_NUM];
+__attribute__((__aligned__(4))) volatile UsbHostDescriptor usb_pipe_table[USB_EPT_NUM];
+extern void (*gpf_isr)(void);
 // NVM Software Calibration Area Mapping
 // USB TRANSN calibration value. Should be written to the USB PADCAL register.
 #define NVM_USB_PAD_TRANSN_POS  45
 #define NVM_USB_PAD_TRANSN_SIZE 5
+#define NVM_USB_PAD_TRANSN_POS     45
+#define NVM_USB_PAD_TRANSN_SIZE    5
 // USB TRANSP calibration value. Should be written to the USB PADCAL register.
 #define NVM_USB_PAD_TRANSP_POS  50
 #define NVM_USB_PAD_TRANSP_SIZE 5
+#define NVM_USB_PAD_TRANSP_POS     50
+#define NVM_USB_PAD_TRANSP_SIZE    5
 // USB TRIM calibration value. Should be written to the USB PADCAL register.
+#define NVM_USB_PAD_TRIM_POS  55
+#define NVM_USB_PAD_TRIM_SIZE 3
+#define NVM_USB_PAD_TRIM_POS       55
+#define NVM_USB_PAD_TRIM_SIZE      3
+static void UHD_ISR(void);
 /**
 …
+{
         uint32_t pad_transn;
+    uint32_t pad_transp;
+    uint32_t pad_trim;
+        uint32_t pad_transp;
+        uint32_t pad_trim;
+        uint32_t i;
+//      USB_SetHandler(&USB_Handler);
+        USB_SetHandler(&UHD_ISR);
         /* Enable USB clock */
         PM->APBBMASK.reg |= PM_APBBMASK_USB;
+        /* Set up the USB DP/DN pins */
+        PORT->Group[0].PINCFG[PIN_PA24G_USB_DM].bit.PMUXEN = 1;
+        PORT->Group[0].PMUX[PIN_PA24G_USB_DM/2].reg &= ~(0xF << (4 * (PIN_PA24G_USB_DM & 0x01u)));
+        PORT->Group[0].PMUX[PIN_PA24G_USB_DM/2].reg |= MUX_PA24G_USB_DM << (4 * (PIN_PA24G_USB_DM & 0x01u));
+        PORT->Group[0].PINCFG[PIN_PA25G_USB_DP].bit.PMUXEN = 1;
+        PORT->Group[0].PMUX[PIN_PA25G_USB_DP/2].reg &= ~(0xF << (4 * (PIN_PA25G_USB_DP & 0x01u)));
+        PORT->Group[0].PMUX[PIN_PA25G_USB_DP/2].reg |= MUX_PA25G_USB_DP << (4 * (PIN_PA25G_USB_DP & 0x01u));
+        /* Set up the USB DP/DM pins */
+        pinPeripheral( 33ul, PIO_COM );
+        pinPeripheral( 34ul, PIO_COM );
         /* ----------------------------------------------------------------------------------------------
          * Put Generic Clock Generator 0 as source for Generic Clock Multiplexer 6 (USB reference)
          */
         GCLK->CLKCTRL.reg = GCLK_CLKCTRL_ID( 6 ) | // Generic Clock Multiplexer 6
                                         GCLK_CLKCTRL_GEN_GCLK0 | // Generic Clock Generator 0 is source
                                         GCLK_CLKCTRL_CLKEN ;
         while ( GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY )
+        {
         /* Wait for synchronization */
+        * Put Generic Clock Generator 0 as source for Generic Clock Multiplexer 6 (USB reference)
+        */
+        GCLK->CLKCTRL.reg = GCLK_CLKCTRL_ID(6) |        // Generic Clock Multiplexer 6
+                                                GCLK_CLKCTRL_GEN_GCLK0 |    // Generic Clock Generator 0 is source
+                                                GCLK_CLKCTRL_CLKEN;
+        while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY)
+        {
+                /* Wait for synchronization */
+        }
         /* Reset */
         USB->HOST.CTRLA.bit.SWRST = 1;
+        while (USB->HOST.SYNCBUSY.bit.SWRST) {
+        while (USB->HOST.SYNCBUSY.bit.SWRST)
+        {
                 /* Sync wait */
+        }
+        udd_enable();
+        //  uhd_enable();
+        USB->DEVICE.CTRLA.reg |= USB_CTRLA_ENABLE | USB_CTRLA_MODE;
+        uhd_force_host_mode();
+        while (USB->HOST.SYNCBUSY.reg == USB_SYNCBUSY_ENABLE);
         /* Load Pad Calibration */
+        pad_transn =( *((uint32_t *)(NVMCTRL_OTP4)  // Non-Volatile Memory Controller
+        + (NVM_USB_PAD_TRANSN_POS / 32))
+        >> (NVM_USB_PAD_TRANSN_POS % 32))
+        & ((1 << NVM_USB_PAD_TRANSN_SIZE) - 1);
+        if (pad_transn == 0x1F) {  // maximum value (31)
+        pad_transn = (*((uint32_t *)(NVMCTRL_OTP4)       // Non-Volatile Memory Controller
+                                        + (NVM_USB_PAD_TRANSN_POS / 32))
+                                        >> (NVM_USB_PAD_TRANSN_POS % 32))
+                                & ((1 << NVM_USB_PAD_TRANSN_SIZE) - 1);
+        if (pad_transn == 0x1F)         // maximum value (31)
+        {
                 pad_transn = 5;
+        }
 …
         USB->HOST.PADCAL.bit.TRANSN = pad_transn;
+        pad_transp =( *((uint32_t *)(NVMCTRL_OTP4)
+        + (NVM_USB_PAD_TRANSP_POS / 32))
+        >> (NVM_USB_PAD_TRANSP_POS % 32))
+        & ((1 << NVM_USB_PAD_TRANSP_SIZE) - 1);
+        if (pad_transp == 0x1F) {  // maximum value (31)
+        pad_transp = (*((uint32_t *)(NVMCTRL_OTP4)
+                                        + (NVM_USB_PAD_TRANSP_POS / 32))
+                                        >> (NVM_USB_PAD_TRANSP_POS % 32))
+                                & ((1 << NVM_USB_PAD_TRANSP_SIZE) - 1);
+        if (pad_transp == 0x1F)         // maximum value (31)
+        {
                 pad_transp = 29;
+        }
 …
         USB->HOST.PADCAL.bit.TRANSP = pad_transp;
+        pad_trim =( *((uint32_t *)(NVMCTRL_OTP4)
+        + (NVM_USB_PAD_TRIM_POS / 32))
+        >> (NVM_USB_PAD_TRIM_POS % 32))
+        & ((1 << NVM_USB_PAD_TRIM_SIZE) - 1);
+        if (pad_trim == 0x7) {  // maximum value (7)
+        pad_trim = (*((uint32_t *)(NVMCTRL_OTP4)
+                                        + (NVM_USB_PAD_TRIM_POS / 32))
+                                >> (NVM_USB_PAD_TRIM_POS % 32))
+                                & ((1 << NVM_USB_PAD_TRIM_SIZE) - 1);
+        if (pad_trim == 0x7)         // maximum value (7)
+        {
                 pad_trim = 3;
+        }
 …
         USB->HOST.PADCAL.bit.TRIM = pad_trim;
         /* Set the configuration */
         udd_force_host_mode();
         udd_device_run_in_standby();
+    // Set address of USB SRAM
         USB->HOST.DESCADD.reg = (uint32_t)(&usb_endpoint_table[0]);
         // For USB_SPEED_FULL
         udd_force_full_speed();
         for (uint32_t i = 0; i < sizeof(usb_endpoint_table); i++) {
                 (*(uint32_t *)(&usb_endpoint_table[0]+i)) = 0;
+        }
+        uhd_run_in_standby();
+        // Set address of USB SRAM
+        USB->HOST.DESCADD.reg = (uint32_t)(&usb_pipe_table[0]);
+        // For USB_SPEED_FULL
+        uhd_force_full_speed();
+        for (i = 0; i < sizeof(usb_pipe_table); i++)
+        {
+                (*(uint32_t *)(&usb_pipe_table[0] + i)) = 0;
+        }
         uhd_state = UHD_STATE_NO_VBUS;
+        // Put VBUS on USB port
+        pinMode( 32ul, OUTPUT );
+        digitalWrite( 32ul, HIGH );
+        uhd_enable_connection_int();
+        USB->HOST.INTENSET.reg = USB_HOST_INTENSET_DCONN;
+        USB->HOST.INTENSET.reg = USB_HOST_INTENSET_WAKEUP;
+        USB->HOST.INTENSET.reg = USB_HOST_INTENSET_DDISC;
         USB->HOST.CTRLB.bit.VBUSOK = 1;
         // Configure interrupts
+        NVIC_SetPriority((IRQn_Type) USB_IRQn, 0UL);
+        NVIC_EnableIRQ((IRQn_Type) USB_IRQn);
+}
+//static void UHD_ISR(void)
+void USB_Handler(void)
+{
+        uint16_t flags;
+        uint8_t i;
+        uint8_t ept_int;
+        ept_int = udd_endpoint_interrupt();
+        /* Not endpoint interrupt */
+        if (0 == ept_int)
+        {
+        }
+        else
+        {
+                /* host interrupts */
+        NVIC_SetPriority((IRQn_Type)USB_IRQn, 0UL);
+        NVIC_EnableIRQ((IRQn_Type)USB_IRQn);
+}
+static void UHD_ISR(void)
+//void USB_Handler(void)
+{
+   uint16_t flags;
+        if (USB->HOST.CTRLA.bit.MODE) {
+                /*host mode ISR */
                 /* get interrupt flags */
 …
                 /* host SOF interrupt */
+                if (flags & USB_HOST_INTFLAG_HSOF) {
+                if (flags & USB_HOST_INTFLAG_HSOF)
+                {
                         /* clear the flag */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_HSOF;
                         uhd_state = UHD_STATE_CONNECTED;
+                        uhd_state             = UHD_STATE_CONNECTED;
                         return;
+                }
                 /* host reset interrupt */
+                if (flags & USB_HOST_INTFLAG_RST) {
+                if (flags & USB_HOST_INTFLAG_RST)
+                {
                         /* clear the flag */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_RST;
                         uhd_state = UHD_STATE_DISCONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_DISCONNECTED;    //UHD_STATE_ERROR;
                         return;
+                }
                 /* host upstream resume interrupts */
+                if (flags & USB_HOST_INTFLAG_UPRSM) {
+                if (flags & USB_HOST_INTFLAG_UPRSM)
+                {
                         /* clear the flags */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_UPRSM;
                         uhd_state = UHD_STATE_DISCONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_DISCONNECTED;    //UHD_STATE_ERROR;
                         return;
+                }
                 /* host downstream resume interrupts */
+                if (flags & USB_HOST_INTFLAG_DNRSM) {
+                if (flags & USB_HOST_INTFLAG_DNRSM)
+                {
                         /* clear the flags */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_DNRSM;
                         uhd_state = UHD_STATE_DISCONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_DISCONNECTED;    //UHD_STATE_ERROR;
                         return;
+                }
                 /* host wakeup interrupts */
+                if (flags & USB_HOST_INTFLAG_WAKEUP) {
+                if (flags & USB_HOST_INTFLAG_WAKEUP)
+                {
                         /* clear the flags */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_WAKEUP;
                         uhd_state = UHD_STATE_CONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_CONNECTED;    //UHD_STATE_ERROR;
                         return;
+                }
                 /* host ram access interrupt  */
+                if (flags & USB_HOST_INTFLAG_RAMACER) {
+                if (flags & USB_HOST_INTFLAG_RAMACER)
+                {
                         /* clear the flag */
                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_RAMACER;
                         uhd_state = UHD_STATE_DISCONNECTED; //UHD_STATE_ERROR;
+                        uhd_state             = UHD_STATE_DISCONNECTED;    //UHD_STATE_ERROR;
                         return;
+                }
                 /* host connect interrupt */
+                if (flags & USB_HOST_INTFLAG_DCONN) {
+                        TRACE_UOTGHS_HOST(printf(">>> UHD_ISR : Connection INT\r\n");)
+                if (flags & USB_HOST_INTFLAG_DCONN)
+                {
+                        TRACE_UOTGHS_HOST(printf(">>> UHD_ISR : Connection INT\r\n");
+                                                        )
                         /* clear the flag */
                         uhd_ack_connection();
 …
+                }
+                /* host disconnect interrupt    */
+                if (flags & USB_HOST_INTFLAG_DDISC) {
+                        TRACE_UOTGHS_HOST(printf(">>> UHD_ISR : Disconnection INT\r\n");)
+                /* host disconnect interrupt  */
+                if (flags & USB_HOST_INTFLAG_DDISC)
+                {
+                        TRACE_UOTGHS_HOST(printf(">>> UHD_ISR : Disconnection INT\r\n");
+                                                        )
                         /* clear the flag */
                         uhd_ack_disconnection();
 …
                         return;
+                }
+        }
+}
+/**
+ * \brief Trigger a USB bus reset.
+ */
+void UHD_BusReset(void)
+{
+        USB->HOST.CTRLB.bit.BUSRESET = 1;;
+}
+        }
+        else {
+                while(1);
+        }
+}
 /**
 …
 uhd_vbus_state_t UHD_GetVBUSState(void)
+{
+        return uhd_state;
+}
+   return uhd_state;
+}
 …
  * \retval 1 error.
  */
+uint32_t UHD_Pipe0_Alloc(uint32_t ul_add, uint32_t ul_ep_size)
+{
+        struct usb_host_pipe_config cfg;
+        if (ep_size < 8)
+        {
+                return 0;
+        }
+        /* set pipe config */
+        USB->HOST.HostPipe[0].PCFG.bit.BK = 0;
+        USB->HOST.HostPipe[0].PCFG.bit.PTYPE = USB_HOST_PIPE_TYPE_CONTROL;
+        USB->HOST.HostPipe[0].BINTERVAL.reg = 0;
+        USB->HOST.HostPipe[0].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_SETUP;
+        memset((uint8_t *)&usb_pipe_table[pipe_num], 0, sizeof(usb_pipe_table[0]));
+        usb_pipe_table[pipe_num].HostDescBank[0].CTRL_PIPE.bit.PDADDR = 0;
+        usb_pipe_table[pipe_num].HostDescBank[0].CTRL_PIPE.bit.PEPNUM = 0;
+        usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.SIZE = 0x03;  // 64 bytes
+        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TRCPT_Msk;
+        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TRFAIL | USB_HOST_PINTENSET_PERR;
+        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TXSTP;
+        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_STALL;
+        return 1;
+}
+uint32_t UHD_Pipe0_Alloc(uint32_t ul_add , uint32_t ul_ep_size)
+{
+        (void)(ul_add); // Unused argument
+        if( USB->HOST.STATUS.reg & USB_HOST_STATUS_SPEED(1) )
+                ul_ep_size = USB_PCKSIZE_SIZE_8_BYTES;  // Low Speed
+        else
+                ul_ep_size = USB_PCKSIZE_SIZE_64_BYTES; // Full Speed
+        USB->HOST.HostPipe[0].PCFG.bit.PTYPE = 1; //USB_HOST_PCFG_PTYPE_CTRL;
+        usb_pipe_table[0].HostDescBank[0].CTRL_PIPE.bit.PEPNUM = 0;
+        usb_pipe_table[0].HostDescBank[0].PCKSIZE.bit.SIZE = ul_ep_size;
+        return 0;
+}
 /**
 …
+{
         /* set pipe config */
+        USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.BK = ul_nb_bank;
+        USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTYPE = ul_type;
+        USB->HOST.HostPipe[ul_dev_ep].BINTERVAL.reg = ul_interval;
+        if (ul_dir & USB_EP_DIR_IN)
+        {
+                USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_IN;
+                USB->HOST.HostPipe[ul_dev_ep].PSTATUSSET.reg = USB_HOST_PSTATUSSET_BK0RDY;
+        }
+        USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.BK    = ul_nb_bank;
+        USB->HOST.HostPipe[ul_dev_ep].PCFG.reg &= ~USB_HOST_PCFG_MASK;  // USB->HOST.HostPipe[0].PCFG.bit.PTYPE = 1; //USB_HOST_PCFG_PTYPE_CTRL;
+        USB->HOST.HostPipe[ul_dev_ep].PCFG.reg |= ul_type;
+        USB->HOST.HostPipe[ul_dev_ep].BINTERVAL.reg  = ul_interval;
+   if (ul_dir & USB_EP_DIR_IN)
+   {
+      USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTOKEN = USB_HOST_PCFG_PTOKEN_IN;
+      USB->HOST.HostPipe[ul_dev_ep].PSTATUSSET.reg  = USB_HOST_PSTATUSSET_BK0RDY;
+   }
+   else
+   {
+      USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTOKEN = USB_HOST_PCFG_PTOKEN_OUT;
+      USB->HOST.HostPipe[ul_dev_ep].PSTATUSCLR.reg  = USB_HOST_PSTATUSCLR_BK0RDY;
+   }
+        if( USB->HOST.STATUS.reg & USB_HOST_STATUS_SPEED(1) )
+           ul_maxsize = USB_PCKSIZE_SIZE_8_BYTES;  // Low Speed
         else
+        {
+                USB->HOST.HostPipe[ul_dev_ep].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_OUT;
+                USB->HOST.HostPipe[ul_dev_ep].PSTATUSCLR.reg =  USB_HOST_PSTATUSCLR_BK0RDY;
+        }
+        memset((uint8_t *)&usb_descriptor_table.usb_pipe_table[ul_dev_ep], 0, sizeof(usb_pipe_table[ul_dev_ep]));
+        usb_descriptor_table.usb_pipe_table[ul_dev_ep].HostDescBank[0].CTRL_PIPE.bit.PDADDR = ul_dev_addr;
+        usb_descriptor_table.usb_pipe_table[ul_dev_ep].HostDescBank[0].CTRL_PIPE.bit.PEPNUM = ul_dev_ep;
+        usb_descriptor_table.usb_pipe_table[ul_dev_ep].HostDescBank[0].PCKSIZE.bit.SIZE = 0x03;  // 64 bytes
+        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TRCPT_Msk;
+        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_TRFAIL | USB_HOST_PINTENSET_PERR;
+        USB->HOST.HostPipe[pipe_num].PINTENSET.reg = USB_HOST_PINTENSET_STALL;
+        return 1;
+}
+           ul_maxsize = USB_PCKSIZE_SIZE_64_BYTES; // Full Speed
+   memset((uint8_t *)&usb_pipe_table[ul_dev_ep], 0, sizeof(usb_pipe_table[ul_dev_ep]));
+   usb_pipe_table[ul_dev_ep].HostDescBank[0].CTRL_PIPE.bit.PDADDR = ul_dev_addr;
+   usb_pipe_table[ul_dev_ep].HostDescBank[0].CTRL_PIPE.bit.PEPNUM = ul_dev_ep;
+   usb_pipe_table[ul_dev_ep].HostDescBank[0].PCKSIZE.bit.SIZE     = ul_maxsize;
+   return 1;
+}
+void UHD_Pipe_CountZero(uint32_t ul_pipe)
+{
+        usb_pipe_table[ul_pipe].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT = 0;
+}
 /**
 …
 void UHD_Pipe_Free(uint32_t ul_pipe)
+{
+        // Unalloc pipe
+        uhd_disable_pipe(ul_pipe);
+        uhd_unallocate_memory(ul_pipe);
+        uhd_reset_pipe(ul_pipe);
+        // The Pipe is frozen and no additional requests will be sent to the device on this pipe address.
+        USB->HOST.HostPipe[pipe_num].PSTATUSSET.reg = USB_HOST_PSTATUSSET_PFREEZE;
+}
+   // The Pipe is frozen and no additional requests will be sent to the device on this pipe address.
+   USB->HOST.HostPipe[ul_pipe].PSTATUSSET.reg = USB_HOST_PSTATUSSET_PFREEZE;
+}
 /**
 …
  * \return number of data read.
  */
+uint32_t UHD_Pipe_Read(uint32_t pipe_num, uint32_t buf_size, uint8_t* buf)
+{
+        if (USB->HOST.HostPipe[pipe_num].PCFG.bit.PTYPE == USB_HOST_PIPE_TYPE_DISABLE)
+        {
+                return 0;
+        }
+        /* get pipe config from setting register */
+        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].ADDR.reg = (uint32_t)buf;
+        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT = 0;
+        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = buf_size;
+        USB->HOST.HostPipe[pipe_num].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_IN;
+        /* Start transfer */
+        USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_BK0RDY;
+        // Unfreeze pipe
+        USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_PFREEZE;
+        return buf_size;
+}
+uint32_t UHD_Pipe_Read(uint32_t pipe_num, uint32_t buf_size, uint8_t *buf)
+{
+   if (USB->HOST.HostPipe[pipe_num].PCFG.bit.PTYPE == USB_HOST_PTYPE_DIS)
+   {
+      return 0;
+   }
+   /* get pipe config from setting register */
+   usb_pipe_table[pipe_num].HostDescBank[0].ADDR.reg = (uint32_t)buf;
+   usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT        = 0;
+   usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = buf_size;
+   USB->HOST.HostPipe[pipe_num].PCFG.bit.PTOKEN = USB_HOST_PCFG_PTOKEN_IN;
+   /* Start transfer */
+   USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_BK0RDY;
+   // Unfreeze pipe
+   USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_PFREEZE;
+   return buf_size;
+}
 /**
 …
  * \param data Buffer containing data to write.
  */
+void UHD_Pipe_Write(uint32_t ul_pipe, uint32_t ul_size, uint8_t* data)
+{
+        if (USB->HOST.HostPipe[pipe_num].PCFG.bit.PTYPE == USB_HOST_PIPE_TYPE_DISABLE)
+        {
+                return 0;
+        }
+        /* get pipe config from setting register */
+        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].ADDR.reg = (uint32_t)buf;
+        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT = buf_size;
+        usb_descriptor_table.usb_pipe_table[pipe_num].HostDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = 0;
+        USB->HOST.HostPipe[pipe_num].PCFG.bit.PTOKEN = USB_HOST_PIPE_TOKEN_OUT;
+        return 1;
+void UHD_Pipe_Write(uint32_t ul_pipe, uint32_t ul_size, uint8_t *buf)
+{
+   /* get pipe config from setting register */
+   usb_pipe_table[ul_pipe].HostDescBank[0].ADDR.reg = (uint32_t)buf;
+   usb_pipe_table[ul_pipe].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT = ul_size;
+   usb_pipe_table[ul_pipe].HostDescBank[0].PCKSIZE.bit.MULTI_PACKET_SIZE = 0;
+}
 …
 void UHD_Pipe_Send(uint32_t ul_pipe, uint32_t ul_token_type)
+{
+        /* Start transfer */
+        USB->HOST.HostPipe[pipe_num].PSTATUSSET.reg = USB_HOST_PSTATUSSET_BK0RDY;
+        USB->HOST.HostPipe[ul_pipe].PCFG.bit.PTOKEN = ul_token_type;
+   /* Start transfer */
+        if(ul_token_type == USB_HOST_PCFG_PTOKEN_SETUP )
+        {
+                USB->HOST.HostPipe[ul_pipe].PINTFLAG.reg = USB_HOST_PINTFLAG_TXSTP;
+                USB->HOST.HostPipe[ul_pipe].PSTATUSSET.reg = USB_HOST_PSTATUSSET_BK0RDY;
+        }
+        else if(ul_token_type == USB_HOST_PCFG_PTOKEN_IN )
+        {
+                USB->HOST.HostPipe[ul_pipe].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_BK0RDY;
+        }
+        else
+        {
+                USB->HOST.HostPipe[ul_pipe].PINTFLAG.reg = USB_HOST_PINTFLAG_TRCPT(1);  // Transfer Complete 0
+                USB->HOST.HostPipe[ul_pipe].PSTATUSSET.reg = USB_HOST_PSTATUSSET_BK0RDY;
+        }
         // Unfreeze pipe
+        USB->HOST.HostPipe[pipe_num].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_PFREEZE;
+}
+    uhd_unfreeze_pipe(ul_pipe);
+}
+#define USB_HOST_PINTFLAG_TRCPT_Pos 0            /**< \brief (USB_HOST_PINTFLAG) Transfer Complete 0/1 Interrupt Flag */
+#define USB_HOST_PINTFLAG_TRCPT_Msk (0x3u << USB_HOST_PINTFLAG_TRCPT_Pos)
+#define USB_HOST_PINTFLAG_TRCPT(value) ((USB_HOST_PINTFLAG_TRCPT_Msk & ((value) << USB_HOST_PINTFLAG_TRCPT_Pos)))
 /**
 …
 uint32_t UHD_Pipe_Is_Transfer_Complete(uint32_t ul_pipe, uint32_t ul_token_type)
+{
+        // Freeze pipe
+        USB->HOST.HostPipe[pipe_num].PSTATUSSET.reg = USB_HOST_PSTATUSSET_PFREEZE;
+        switch(uhd_ctrl_request_phase) {
+                case UHD_CTRL_REQ_PHASE_DATA_IN:
+                _uhd_ctrl_phase_data_in(p_callback_para->transfered_size);
+                break;
+                case UHD_CTRL_REQ_PHASE_ZLP_IN:
+                _uhd_ctrl_request_end(UHD_TRANS_NOERROR);
+                break;
+                case UHD_CTRL_REQ_PHASE_DATA_OUT:
+                _uhd_ctrl_phase_data_out();
+                break;
+                case UHD_CTRL_REQ_PHASE_ZLP_OUT:
+                _uhd_ctrl_request_end(UHD_TRANS_NOERROR);
+                break;
+        }
+        return 0;
+}
+#endif
+   // Check for transfer completion depending on token type
+   switch (ul_token_type)
+   {
+      case USB_HOST_PCFG_PTOKEN_SETUP:
+         if (Is_uhd_setup_ready(ul_pipe))
+         {
+            uhd_ack_setup_ready(ul_pipe);
+            uhd_freeze_pipe(ul_pipe);
+            return 1;
+         }
+                 break;
+      case USB_HOST_PCFG_PTOKEN_IN:
+         if (Is_uhd_in_received(ul_pipe))
+         {
+            // IN packet received
+            uhd_ack_in_received(ul_pipe);
+                        // Freeze will stop after the transfer
+                        uhd_freeze_pipe(ul_pipe);
+            return 1;
+         }
+                 break;
+      case USB_HOST_PCFG_PTOKEN_OUT:
+         if (Is_uhd_out_ready(ul_pipe))
+         {
+            // OUT packet sent
+            uhd_ack_out_ready(ul_pipe);
+            uhd_freeze_pipe(ul_pipe);
+            return 1;
+         }
+                 break;
+   }
+   return 0;
+}
+#endif //  HOST_DEFINED

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/USB/samd21_host.h

-              r136
+              r224
+/* ----------------------------------------------------------------------------
+ *         SAM Software Package License
+ * ----------------------------------------------------------------------------
+ * Copyright (c) 2011-2012, Atmel Corporation
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following condition is met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the disclaimer below.
+ *
+ * Atmel's name may not be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ----------------------------------------------------------------------------
+ */
+/*
+  Copyright (c) 2014 Arduino LLC.  All right reserved.
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+/*
+**Modified 04/04/2016 by Arduino.org development team
+*/
 #ifndef UOTGHS_HOST_H_INCLUDED
 #define UOTGHS_HOST_H_INCLUDED
 #ifdef __cplusplus
 …
 #endif
+//! \ingroup usb_host_group
+//! \defgroup uhd_group USB Host Driver (UHD)
+//! UOTGHS low-level driver for USB host mode
+//!
+//! @{
+extern __attribute__((__aligned__(4))) volatile UsbHostDescriptor usb_pipe_table[USB_EPT_NUM];
+//! @name UOTGHS Host IP properties
+//!
+//! @{
+//! Get maximal number of endpoints
+#define uhd_get_pipe_max_nbr()                (9)
+#define UOTGHS_EPT_NUM                        (uhd_get_pipe_max_nbr()+1)
+//! @}
+#define  USB_EP_DIR_IN        0x80  // USB_SETUP_DEVICE_TO_HOST
+#define  USB_EP_DIR_OUT       0x00  // USB_SETUP_HOST_TO_DEVICE
+//! @name Host Vbus line control
+//!
+//! VBOF is an optional output pin which allows to enable or disable
+//! the external VBus generator.
+//!
+//! @{
+//! Enables hardware control of USB_VBOF output pin when a Vbus error occur
+#define uhd_enable_vbus_error_hw_control()    (Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBUSHWC))
+//! Disables hardware control of USB_VBOF output pin when a Vbus error occur
+#define uhd_disable_vbus_error_hw_control()   (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBUSHWC))
+#define USB_HOST_PTYPE_DIS     USB_HOST_PCFG_PTYPE(0x0) // Pipe is disabled
+#define USB_HOST_PTYPE_CTRL    USB_HOST_PCFG_PTYPE(0x1) // Pipe is enabled and configured as CONTROL
+#define USB_HOST_PTYPE_ISO     USB_HOST_PCFG_PTYPE(0x2) // Pipe is enabled and configured as ISO
+#define USB_HOST_PTYPE_BULK    USB_HOST_PCFG_PTYPE(0x3) // Pipe is enabled and configured as BULK
+#define USB_HOST_PTYPE_INT     USB_HOST_PCFG_PTYPE(0x4) // Pipe is enabled and configured as INTERRUPT
+#define USB_HOST_PTYPE_EXT     USB_HOST_PCFG_PTYPE(0x5) // Pipe is enabled and configured as EXTENDED
+//! Pin and function for USB_VBOF according to configuration from USB_VBOF
+#define USB_VBOF_PIN            USB_VBOF_GPIO
+#define USB_VBOF_FUNCTION       USB_VBOF_FLAGS
+//! Output USB_VBOF onto its pin
+#define uhd_output_vbof_pin() do {\
+        pio_configure_pin(USB_VBOF_PIN, USB_VBOF_FUNCTION); \
+} while (0)
+#define USB_HOST_NB_BK_1                1
+//! Set USB_VBOF output pin polarity
+#define uhd_set_vbof_active_high()            (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBUSPO))
+#define uhd_set_vbof_active_low()             (Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBUSPO))
+//! Requests VBus activation
+#define uhd_enable_vbus()                     (Set_bits(UOTGHS->UOTGHS_SFR, UOTGHS_SR_VBUSRQ))
+//! Requests VBus deactivation
+#define uhd_disable_vbus()                    (Set_bits(UOTGHS->UOTGHS_SCR, UOTGHS_SR_VBUSRQ))
+//! Tests if VBus activation has been requested
+#define Is_uhd_vbus_enabled()                 (Tst_bits(UOTGHS->UOTGHS_SR, UOTGHS_SR_VBUSRQ))
+//! @}
+#define USB_HOST_PCFG_PTOKEN_SETUP  USB_HOST_PCFG_PTOKEN(0x0)
+#define USB_HOST_PCFG_PTOKEN_IN     USB_HOST_PCFG_PTOKEN(0x1)
+#define USB_HOST_PCFG_PTOKEN_OUT    USB_HOST_PCFG_PTOKEN(0x2)
+//! @name Host Vbus line monitoring
+//!
+//! The VBus level is always checked by USBC hardware.
+//!
+//! @{
+#define uhd_enable_vbus_error_interrupt()     (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBERRE))
+#define uhd_disable_vbus_error_interrupt()    (Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBERRE))
+#define Is_uhd_vbus_error_interrupt_enabled() (Tst_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBERRE))
+#define uhd_ack_vbus_error_interrupt()        (Set_bits(UOTGHS->UOTGHS_SCR, UOTGHS_SCR_VBERRIC))
+#define Is_uhd_vbus_error_interrupt()         (Tst_bits(UOTGHS->UOTGHS_SR, UOTGHS_SR_VBERRI))
+//! @}
+#define USB_ERRORFLOW         USB_HOST_STATUS_BK_ERRORFLOW
+#define USB_ERRORTIMEOUT      USB_HOST_STATUS_PIPE_TOUTER
+#define USB_ERROR_DATATOGGLE  USB_HOST_STATUS_PIPE_DTGLER
+#define uhd_ack_errors_interrupt()            (UOTGHS->UOTGHS_SCR = (UOTGHS_SCR_VBERRIC|UOTGHS_SCR_BCERRIC|UOTGHS_SCR_HNPERRIC|UOTGHS_SCR_STOIC))
+#define Is_uhd_errors_interrupt()             (Tst_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_VBERRE|UOTGHS_CTRL_BCERRE|UOTGHS_CTRL_HNPERRE|UOTGHS_CTRL_STOE))
+#define uhd_enable_suspend_error_interrupt()
+#define uhd_enable_hnp_error_interrupt()
+#define uhd_enable_bconn_error_interrupt()
+#define USB_PCKSIZE_SIZE_8_BYTES        0
+#define USB_PCKSIZE_SIZE_16_BYTES       1
+#define USB_PCKSIZE_SIZE_32_BYTES       2
+#define USB_PCKSIZE_SIZE_64_BYTES       3
+#define USB_PCKSIZE_SIZE_128_BYTES      4
+#define USB_PCKSIZE_SIZE_256_BYTES      5
+#define USB_PCKSIZE_SIZE_512_BYTES      6
+#define USB_PCKSIZE_SIZE_1023_BYTES_FS  7
+#define USB_PCKSIZE_SIZE_1024_BYTES_HS  7
+//! @name USB device connection/disconnection monitoring
+//! @{
+#define uhd_enable_connection_int()           (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_DCONNIES)
+#define uhd_disable_connection_int()          (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_DCONNIEC)
+#define Is_uhd_connection_int_enabled()       (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_DCONNIE))
+#define uhd_ack_connection()                  (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_DCONNIC)
+#define Is_uhd_connection()                   (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_DCONNI))
+#define USB_HOST_DTGL(p)               (USB->HOST.HostPipe[p].PSTATUS.reg & USB_HOST_PSTATUS_DTGL)>>USB_HOST_PSTATUS_DTGL_Pos
+#define uhd_enable_disconnection_int()        (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_DDISCIES)
+#define uhd_disable_disconnection_int()       (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_DDISCIEC)
+#define Is_uhd_disconnection_int_enabled()    (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_DDISCIE))
+#define uhd_ack_disconnection()               (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_DDISCIC)
+#define Is_uhd_disconnection()                (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_DDISCI))
+//! @}
+// USB host connection/disconnection monitoring
+#define uhd_enable_connection_int()           USB->HOST.INTENSET.reg = USB_HOST_INTENSET_DCONN
+#define uhd_disable_connection_int()          USB->HOST.INTENCLR.reg = USB_HOST_INTENCLR_DCONN
+#define uhd_ack_connection()                  USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_DCONN
+//! @name USB device speed control
+//! @{
+#define uhd_get_speed_mode()                  (Rd_bits(UOTGHS->UOTGHS_SR, UOTGHS_SR_SPEED_Msk))
+#define Is_uhd_low_speed_mode()                 (uhd_get_speed_mode() == UOTGHS_SR_SPEED_LOW_SPEED)
+#define Is_uhd_full_speed_mode()                (uhd_get_speed_mode() == UOTGHS_SR_SPEED_FULL_SPEED)
+#define Is_uhd_high_speed_mode()                (uhd_get_speed_mode() == UOTGHS_SR_SPEED_HIGH_SPEED)
+//! Enable high speed mode
+# define uhd_enable_high_speed_mode()        (Wr_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SPDCONF_Msk, UOTGHS_HSTCTRL_SPDCONF_HIGH_SPEED))
+//! Disable high speed mode
+# define uhd_disable_high_speed_mode()       (Wr_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SPDCONF_Msk, UOTGHS_HSTCTRL_SPDCONF_FORCED_FS))
+//! @}
+#define uhd_enable_disconnection_int()        USB->HOST.INTENSET.reg = USB_HOST_INTENSET_DDISC
+#define uhd_disable_disconnection_int()       USB->HOST.INTENCLR.reg = USB_HOST_INTENCLR_DDISC
+#define uhd_ack_disconnection()               USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_DDISC
+//! @name Bus events control
+//! These macros manage the bus events: reset, SOF, resume, wakeup.
+//! @{
+// Initiates a USB register reset
+#define uhd_start_USB_reg_reset()             USB->HOST.CTRLA.bit.SWRST = 1;
+//! Initiates a reset event
+//! @{
+#define uhd_start_reset()                            (Set_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESET))
+#define Is_uhd_starting_reset()                      (Tst_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESET))
+#define uhd_stop_reset()                             (Clr_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESET))
+// Bus Reset
+#define Is_uhd_starting_reset()             (USB->HOST.CTRLB.bit.BUSRESET == 1)
+#define UHD_BusReset()                      USB->HOST.CTRLB.bit.BUSRESET = 1
+#define uhd_stop_reset()                    // nothing to do
+#define uhd_enable_reset_sent_interrupt()            (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_RSTIES)
+#define uhd_disable_reset_sent_interrupt()           (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_RSTIEC)
+#define Is_uhd_reset_sent_interrupt_enabled()        (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_RSTIE))
+#define uhd_ack_reset_sent()                         (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_RSTIC)
+#define Is_uhd_reset_sent()                          (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_RSTI))
+//! @}
+#define uhd_ack_reset_sent()                         USB->HOST.INTFLAG.reg = USB_HOST_INTFLAG_RST
+#define Is_uhd_reset_sent()                          (USB->HOST.INTFLAG.reg & USB_HOST_INTFLAG_RST)
+//! Initiates a SOF events
+//! @{
+#define uhd_enable_sof()                             (Set_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SOFE))
+#define uhd_disable_sof()                            (Clr_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SOFE))
+#define Is_uhd_sof_enabled()                         (Tst_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_SOFE))
+#define uhd_get_sof_number()                         ((UOTGHS->UOTGHS_HSTFNUM&UOTGHS_HSTFNUM_FNUM_Msk)>>UOTGHS_HSTFNUM_FNUM_Pos)
+#define uhd_get_microsof_number()                    ((UOTGHS->UOTGHS_HSTFNUM&UOTGHS_HSTFNUM_MFNUM_Msk)>>UOTGHS_HSTFNUM_MFNUM_Pos)
+#define uhd_get_frame_position()                     (Rd_bits(UOTGHS->UOTGHS_HSTFNUM, UOTGHS_HSTFNUM_FLENHIGH_Msk))
+#define uhd_enable_sof_interrupt()                   (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_HSOFIES)
+#define uhd_disable_sof_interrupt()                  (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_HSOFIEC)
+#define Is_uhd_sof_interrupt_enabled()               (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_HSOFIE))
+#define uhd_ack_sof()                                (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_HSOFIC)
+#define Is_uhd_sof()                                 (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_HSOFI))
+//! @}
+// Initiates a SOF events
+#define uhd_enable_sof()                             USB->HOST.CTRLB.bit.SOFE = 1
+#define uhd_disable_sof()                            USB->HOST.CTRLB.bit.SOFE = 0
+#define Is_uhd_sof_enabled()                         (USB->HOST.CTRLB & USB_HOST_CTRLB_SOFE)
+#define Is_uhd_sof()                                 (USB->HOST.INTFLAG.reg & USB_HOST_INTFLAG_HSOF)
+//! Initiates a resume event
+//! It is called downstream resume event.
+//! @{
+#define uhd_send_resume()                            (Set_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESUME))
+#define Is_uhd_sending_resume()                      (Tst_bits(UOTGHS->UOTGHS_HSTCTRL, UOTGHS_HSTCTRL_RESUME))
+// USB address of pipes
+#define uhd_configure_address(pipe_num, addr) usb_pipe_table[pipe_num].HostDescBank[0].CTRL_PIPE.bit.PDADDR = addr
+#define uhd_get_configured_address(pipe_num)  usb_pipe_table[pipe_num].HostDescBank[0].CTRL_PIPE.bit.PDADDR
+#define uhd_enable_downstream_resume_interrupt()     (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_RSMEDIES)
+#define uhd_disable_downstream_resume_interrupt()    (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_RSMEDIEC)
+#define Is_uhd_downstream_resume_interrupt_enabled() (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_RSMEDIE))
+#define uhd_ack_downstream_resume()                  (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_RSMEDIC)
+#define Is_uhd_downstream_resume()                   (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_RSMEDI))
+//! @}
+// Pipes
+#define uhd_freeze_pipe(p)                       USB->HOST.HostPipe[p].PSTATUSSET.reg = USB_HOST_PSTATUSSET_PFREEZE
+#define uhd_unfreeze_pipe(p)                     USB->HOST.HostPipe[p].PSTATUSCLR.reg = USB_HOST_PSTATUSCLR_PFREEZE
+#define Is_uhd_pipe_frozen(p)                    ((USB->HOST.HostPipe[p].PSTATUS.reg&USB_HOST_PSTATUS_PFREEZE)==USB_HOST_PSTATUS_PFREEZE)
+//! Detection of a wake-up event
+//! A wake-up event is received when the host controller is in the suspend mode:
+//! - and an upstream resume from the peripheral is detected.
+//! - and a peripheral disconnection is detected.
+//! @{
+#define uhd_enable_wakeup_interrupt()                (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_HWUPIES)
+#define uhd_disable_wakeup_interrupt()               (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_HWUPIEC)
+#define Is_uhd_wakeup_interrupt_enabled()            (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_HWUPIE))
+#define uhd_ack_wakeup()                             (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_HWUPIC)
+#define Is_uhd_wakeup()                              (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_HWUPI))
+// Pipe configuration
+#define uhd_configure_pipe_token(p, token)       USB->HOST.HostPipe[p].PCFG.bit.PTOKEN = token
+#define uhd_enable_upstream_resume_interrupt()       (UOTGHS->UOTGHS_HSTIER = UOTGHS_HSTIER_RXRSMIES)
+#define uhd_disable_upstream_resume_interrupt()      (UOTGHS->UOTGHS_HSTIDR = UOTGHS_HSTIDR_RXRSMIEC)
+#define Is_uhd_upstream_resume_interrupt_enabled()   (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_RXRSMIE))
+#define uhd_ack_upstream_resume()                    (UOTGHS->UOTGHS_HSTICR = UOTGHS_HSTICR_RXRSMIC)
+#define Is_uhd_upstream_resume()                     (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_RXRSMI))
+//! @}
+//! @}
+// Pipe data management
+#define uhd_byte_count(p)                        usb_pipe_table[p].HostDescBank[0].PCKSIZE.bit.BYTE_COUNT
+#define uhd_ack_setup_ready(p)                   USB->HOST.HostPipe[p].PINTFLAG.reg = USB_HOST_PINTFLAG_TXSTP
+#define Is_uhd_setup_ready(p)                    ((USB->HOST.HostPipe[p].PINTFLAG.reg&USB_HOST_PINTFLAG_TXSTP) == USB_HOST_PINTFLAG_TXSTP)
+#define uhd_ack_in_received(p)                   USB->HOST.HostPipe[p].PINTFLAG.reg = USB_HOST_PINTFLAG_TRCPT(1)
+#define Is_uhd_in_received(p)                    ((USB->HOST.HostPipe[p].PINTFLAG.reg&USB_HOST_PINTFLAG_TRCPT(1)) == USB_HOST_PINTFLAG_TRCPT(1))
+#define uhd_ack_out_ready(p)                     USB->HOST.HostPipe[p].PINTFLAG.reg = USB_HOST_PINTFLAG_TRCPT(1)
+#define Is_uhd_out_ready(p)                      ((USB->HOST.HostPipe[p].PINTFLAG.reg&USB_HOST_PINTFLAG_TRCPT(1)) == USB_HOST_PINTFLAG_TRCPT(1))
+#define uhd_ack_nak_received(p)                  usb_pipe_table[p].HostDescBank[1].STATUS_BK.reg &= ~USB_HOST_STATUS_BK_ERRORFLOW
+#define Is_uhd_nak_received(p)                   (usb_pipe_table[p].HostDescBank[1].STATUS_BK.reg & USB_HOST_STATUS_BK_ERRORFLOW)
+// Endpoint Interrupt Summary
+#define uhd_endpoint_interrupt()            USB->HOST.PINTSMRY.reg
+//! @name Pipes management
+//! @{
+// Run in Standby
+#define uhd_run_in_standby()                USB->HOST.CTRLA.reg |= USB_CTRLA_RUNSTDBY
+// Force host mode
+#define uhd_force_host_mode()               USB->HOST.CTRLA.reg |= USB_CTRLA_MODE
+//! USB address of pipes
+//! @{
+#define uhd_configure_address(p, addr) \
+                (Wr_bitfield((&UOTGHS->UOTGHS_HSTADDR1)[(p)>>2], \
+                UOTGHS_HSTADDR1_HSTADDRP0_Msk << (((p)&0x03)<<3), addr))
+#define uhd_get_configured_address(p) \
+                (Rd_bitfield((&UOTGHS->UOTGHS_HSTADDR1)[(p)>>2], \
+                UOTGHS_HSTADDR1_HSTADDRP0_Msk << (((p)&0x03)<<3)))
+//! @}
+// Enable USB macro
+#define uhd_enable()                        USB->HOST.CTRLA.reg |= USB_CTRLA_ENABLE
+// Disable USB macro
+#define uhd_disable()                       USB->HOST.CTRLA.reg &= ~USB_CTRLA_ENABLE
+//! Pipe enable
+//! Enable, disable, reset, freeze
+//! @{
+#define uhd_enable_pipe(p) \
+                (Set_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
+#define uhd_disable_pipe(p) \
+                (Clr_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
+#define Is_uhd_pipe_enabled(p) \
+                (Tst_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
+#define uhd_reset_pipe(p) \
+                (Set_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p))); \
+                (Clr_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
+#define Is_uhd_resetting_pipe(p) \
+                (Tst_bits(UOTGHS->UOTGHS_HSTPIP, UOTGHS_HSTPIP_PEN0 << (p)))
+#define uhd_freeze_pipe(p)                       (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_PFREEZES)
+#define uhd_unfreeze_pipe(p)                     (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_PFREEZEC)
+#define Is_uhd_pipe_frozen(p)                    (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_PFREEZE))
+#define uhd_reset_data_toggle(p)                 (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_RSTDTS)
+#define Is_uhd_data_toggle_reset(p)              (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_RSTDT))
+//! @}
+//! Pipe configuration
+//! @{
+#define uhd_configure_pipe_int_req_freq(p,freq)  (Wr_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_INTFRQ_Msk, (freq)))
+#define uhd_get_pipe_int_req_freq(p)             (Rd_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_INTFRQ_Msk))
+#define uhd_configure_pipe_endpoint_number(p,ep) (Wr_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PEPNUM_Msk, (ep)))
+#define uhd_get_pipe_endpoint_address(p) \
+                (uhd_is_pipe_in(p) ?\
+                        (uhd_get_pipe_endpoint_number(p) | USB_EP_DIR_IN) :\
+                        (uhd_get_pipe_endpoint_number(p) | USB_EP_DIR_OUT))
+#define uhd_get_pipe_endpoint_number(p)          (Rd_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], (UOTGHS_HSTPIPCFG_PEPNUM_Msk)))
+#define uhd_configure_pipe_type(p, type)         (Wr_bitfield(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PTYPE_Msk, type))
+#define uhd_get_pipe_type(p)                     (Rd_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PTYPE_Msk))
+#define uhd_enable_pipe_bank_autoswitch(p)       (Set_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_AUTOSW))
+#define uhd_disable_pipe_bank_autoswitch(p)      (Clr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_AUTOSW))
+#define Is_uhd_pipe_bank_autoswitch_enabled(p)   (Tst_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_AUTOSW))
+#define uhd_configure_pipe_token(p, token)       (Wr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PTOKEN_Msk, token))
+#define uhd_get_pipe_token(p)                    (Rd_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PTOKEN_Msk))
+#define uhd_is_pipe_in(p)                        (UOTGHS_HSTPIPCFG_PTOKEN_IN==uhd_get_pipe_token(p))
+#define uhd_is_pipe_out(p)                       (UOTGHS_HSTPIPCFG_PTOKEN_OUT==uhd_get_pipe_token(p))
+//! Bounds given integer size to allowed range and rounds it up to the nearest
+//! available greater size, then applies register format of UOTGHS controller
+//! for pipe size bit-field.
+#define uhd_format_pipe_size(size) \
+                (32 - clz(((uint32_t)min(max(size, 8), 1024) << 1) - 1) - 1 - 3)
+#define uhd_configure_pipe_size(p,size) \
+                (Wr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PSIZE_Msk, uhd_format_pipe_size(size)))
+#define uhd_get_pipe_size(p)                     (8<<((Rd_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], (UOTGHS_HSTPIPCFG_PSIZE_Msk)))>> UOTGHS_HSTPIPCFG_PSIZE_Pos))
+#define uhd_configure_pipe_bank(p,bank)          (Wr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PBK_Msk, (bank)))
+#define uhd_get_pipe_bank(p)                     (Rd_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PBK_Msk))
+#define uhd_allocate_memory(p)                   (Set_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_ALLOC))
+#define uhd_unallocate_memory(p)                 (Clr_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_ALLOC))
+#define Is_uhd_memory_allocated(p)               (Tst_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_ALLOC))
+//! Enable PING management only available in HS mode
+#  define uhd_enable_ping(p)                     (Set_bits(UOTGHS->UOTGHS_HSTPIPCFG[p], UOTGHS_HSTPIPCFG_PINGEN))
+//#endif
+#define uhd_configure_pipe(p, freq, ep_num, type, token, size, bank, bank_switch) \
+        (UOTGHS->UOTGHS_HSTPIPCFG[p] = \
+                (bank)|\
+                ((uhd_format_pipe_size(size)<<UOTGHS_HSTPIPCFG_PSIZE_Pos)&UOTGHS_HSTPIPCFG_PSIZE_Msk)|\
+                ((token)&UOTGHS_HSTPIPCFG_PTOKEN_Msk)|\
+                ((type)&UOTGHS_HSTPIPCFG_PTYPE_Msk)|\
+                (((ep_num)<<UOTGHS_HSTPIPCFG_PEPNUM_Pos)&UOTGHS_HSTPIPCFG_PEPNUM_Msk)|\
+                bank_switch |\
+                (((freq)<<UOTGHS_HSTPIPCFG_INTFRQ_Pos)&UOTGHS_HSTPIPCFG_INTFRQ_Msk))
+#define Is_uhd_pipe_configured(p)                (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_CFGOK))
+//! @}
+//! Pipe main interrupts management
+//! @{
+#define uhd_enable_pipe_interrupt(p)            (UOTGHS->UOTGHS_HSTIER = (UOTGHS_HSTIER_PEP_0 << (p)))
+#define uhd_disable_pipe_interrupt(p)           (UOTGHS->UOTGHS_HSTIDR = (UOTGHS_HSTIDR_PEP_0 << (p)))
+#define Is_uhd_pipe_interrupt_enabled(p)        (Tst_bits(UOTGHS->UOTGHS_HSTIMR, UOTGHS_HSTIMR_PEP_0 << (p)))
+#define Is_uhd_pipe_interrupt(p)                (Tst_bits(UOTGHS->UOTGHS_HSTISR, UOTGHS_HSTISR_PEP_0 << (p)))
+//! returns the lowest pipe number generating a pipe interrupt or UOTGHS_EPT_NUM if none
+#define uhd_get_interrupt_pipe_number() \
+        (ctz(((UOTGHS->UOTGHS_HSTISR >> 8) & (UOTGHS->UOTGHS_HSTIMR >> 8)) | (1 << UOTGHS_EPT_NUM)))
+//! @}
+//! Pipe overflow and underflow for isochronous and interrupt endpoints
+//! @{
+#define uhd_enable_overflow_interrupt(p)         (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_OVERFIES)
+#define uhd_disable_overflow_interrupt(p)        (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_OVERFIEC)
+#define Is_uhd_overflow_interrupt_enabled(p)     (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_OVERFIE))
+#define uhd_ack_overflow_interrupt(p)            (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_OVERFIC)
+#define Is_uhd_overflow(p)                       (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_OVERFI))
+#define uhd_enable_underflow_interrupt(p)        (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_UNDERFIES)
+#define uhd_disable_underflow_interrupt(p)       (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_UNDERFIEC)
+#define Is_uhd_underflow_interrupt_enabled(p)    (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_UNDERFIE))
+#define uhd_ack_underflow_interrupt(p)           (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_UNDERFIC)
+#define Is_uhd_underflow(p)                      (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_UNDERFI))
+//! @}
+//! USB packet errors management
+//! @{
+#define uhd_enable_stall_interrupt(p)            (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_RXSTALLDES)
+#define uhd_disable_stall_interrupt(p)           (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_RXSTALLDEC)
+#define Is_uhd_stall_interrupt_enabled(p)        (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_RXSTALLDE))
+#define uhd_ack_stall(p)                         (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_RXSTALLDIC)
+#define Is_uhd_stall(p)                          (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_RXSTALLDI))
+#define uhd_enable_pipe_error_interrupt(p)       (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_PERRES)
+#define uhd_disable_pipe_error_interrupt(p)      (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_PERREC)
+#define Is_uhd_pipe_error_interrupt_enabled(p)   (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_PERRE))
+#define uhd_ack_all_errors(p)                    (UOTGHS->UOTGHS_HSTPIPERR[p] = 0UL)
+#define Is_uhd_pipe_error(p)                     (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_PERRI))
+#define uhd_error_status(p)                      (UOTGHS->UOTGHS_HSTPIPERR[p])
+#define Is_uhd_bad_data_toggle(p)                (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_DATATGL))
+#define Is_uhd_data_pid_error(p)                 (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_DATAPID))
+#define Is_uhd_pid_error(p)                      (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_PID))
+#define Is_uhd_timeout_error(p)                  (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_TIMEOUT))
+#define Is_uhd_crc16_error(p)                    (Tst_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_CRC16))
+#define uhd_get_error_counter(p)                 (Rd_bits(UOTGHS->UOTGHS_HSTPIPERR[p], UOTGHS_HSTPIPERR_COUNTER))
+//! @}
+//! Pipe data management
+//! @{
+#define uhd_data_toggle(p)                       (Rd_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_DTSEQ))
+#define uhd_enable_bank_interrupt(p)             (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_NBUSYBKES)
+#define uhd_disable_bank_interrupt(p)            (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_NBUSYBKEC)
+#define Is_uhd_bank_interrupt_enabled(p)         (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_NBUSYBKE))
+#define uhd_nb_busy_bank(p)                      (Rd_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_NBUSYBK_Msk))
+#define uhd_current_bank(p)                      (Rd_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_CURRBK_Msk ))
+#define uhd_enable_short_packet_interrupt(p)     (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_SHORTPACKETES)
+#define uhd_disable_short_packet_interrupt(p)    (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_SHORTPACKETIEC)
+#define Is_uhd_short_packet_interrupt_enabled(p) (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_SHORTPACKETIE))  )
+#define uhd_ack_short_packet(p)                  (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_SHORTPACKETIC)
+#define Is_uhd_short_packet(p)                   (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_SHORTPACKETI))
+#define uhd_byte_count(p)                        (Rd_bitfield(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_PBYCT_Msk))
+#define Is_uhd_fifocon(p)                        (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_FIFOCON))
+#define uhd_ack_fifocon(p)                       (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_FIFOCONC)
+#define uhd_enable_setup_ready_interrupt(p)      (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_TXSTPES)
+#define uhd_disable_setup_ready_interrupt(p)     (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_TXSTPEC)
+#define Is_uhd_setup_ready_interrupt_enabled(p)  (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_TXSTPE))
+#define uhd_ack_setup_ready(p)                   (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_TXSTPIC)
+#define Is_uhd_setup_ready(p)                    (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_TXSTPI))
+#define uhd_enable_in_received_interrupt(p)      (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_RXINES)
+#define uhd_disable_in_received_interrupt(p)     (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_RXINEC)
+#define Is_uhd_in_received_interrupt_enabled(p)  (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_RXINE))
+#define uhd_ack_in_received(p)                   (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_RXINIC)
+#define Is_uhd_in_received(p)                    (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_RXINI))
+#define uhd_enable_out_ready_interrupt(p)        (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_TXOUTES)
+#define uhd_disable_out_ready_interrupt(p)       (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_TXOUTEC)
+#define Is_uhd_out_ready_interrupt_enabled(p)    (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_TXOUTE))
+#define uhd_ack_out_ready(p)                     (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_TXOUTIC)
+#define Is_uhd_out_ready(p)                      (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_TXOUTI))
+#define uhd_raise_out_ready(p)                   (UOTGHS->UOTGHS_HSTPIPIFR[p] = UOTGHS_HSTPIPIFR_TXOUTIS)
+#define uhd_enable_nak_received_interrupt(p)     (UOTGHS->UOTGHS_HSTPIPIER[p] = UOTGHS_HSTPIPIER_NAKEDES)
+#define uhd_disable_nak_received_interrupt(p)    (UOTGHS->UOTGHS_HSTPIPIDR[p] = UOTGHS_HSTPIPIDR_NAKEDEC)
+#define Is_uhd_nak_received_interrupt_enabled(p) (Tst_bits(UOTGHS->UOTGHS_HSTPIPIMR[p], UOTGHS_HSTPIPIMR_NAKEDE))
+#define uhd_ack_nak_received(p)                  (UOTGHS->UOTGHS_HSTPIPICR[p] = UOTGHS_HSTPIPICR_NAKEDIC)
+#define Is_uhd_nak_received(p)                   (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_NAKEDI))
+#define Is_uhd_read_enabled(p)                   (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_RWALL))
+#define Is_uhd_write_enabled(p)                  (Tst_bits(UOTGHS->UOTGHS_HSTPIPISR[p], UOTGHS_HSTPIPISR_RWALL ))
+#define uhd_enable_continuous_in_mode(p)         (Set_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], UOTGHS_HSTPIPINRQ_INMODE))
+#define uhd_disable_continuous_in_mode(p)        (Clr_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], UOTGHS_HSTPIPINRQ_INMODE))
+#define Is_uhd_continuous_in_mode_enabled(p)     (Tst_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], UOTGHS_HSTPIPINRQ_INMODE))
+#define uhd_in_request_number(p, in_num)         (Set_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], (in_num)-1))
+#define uhd_get_in_request_number(p)             (((Rd_bits(UOTGHS->UOTGHS_HSTPIPINRQ[p], UOTGHS_HSTPIPINRQ_INRQ_Msk))>>UOTGHS_HSTPIPINRQ_INRQ_Pos)+1)
+//! @}
+//! Maximum transfer size on USB DMA
+#define UHD_PIPE_MAX_TRANS 0x8000
+//! Get 64-, 32-, 16- or 8-bit access to FIFO data register of selected pipe.
+//! @param p      Target Pipe number
+//! @param scale  Data scale in bits: 64, 32, 16 or 8
+//! @return       Volatile 64-, 32-, 16- or 8-bit data pointer to FIFO data register
+//! @warning It is up to the user of this macro to make sure that all accesses
+//! are aligned with their natural boundaries except 64-bit accesses which
+//! require only 32-bit alignment.
+//! @warning It is up to the user of this macro to make sure that used HSB
+//! addresses are identical to the DPRAM internal pointer modulo 32 bits.
+#define uhd_get_pipe_fifo_access(p, scale) \
+        (((volatile TPASTE2(U, scale) (*)[UHD_PIPE_MAX_TRANS / ((scale) / 8)])UOTGHS_RAM_ADDR)[(p)])
+// Force full speed mode
+#define uhd_force_full_speed()              USB->HOST.CTRLB.reg &= ~USB_HOST_CTRLB_SPDCONF_Msk
 #ifdef __cplusplus

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/avr/dtostrf.c

r136	r224
20	20
21	21	char dtostrf (double val, signed char width, unsigned char prec, char sout) {
	22	asm(".global _printf_float");
22	23	char fmt[20];
23	24	sprintf(fmt, "%%%d.%df", width, prec);

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/startup.c

-              r136
+              r224
 void HardFault_Handler( void )
+{
   while ( 1 )
+  {
+  }
+         while ( 1 )
+  {
+         }
+}
 …
 void NVMCTRL_Handler         ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
 void DMAC_Handler            ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
 void USB_Handler             ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
+void USB_Handler             ( void ) __attribute__ ((weak));
 void EVSYS_Handler           ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
 void SERCOM0_Handler         ( void ) __attribute__ ((weak, alias("Dummy_Handler")));
 …
   while ( 1 )
+  {
+  }
+}
+ }
+}
+static void (*usb_isr)(void) = NULL;
+void USB_Handler(void)
+{
+  if (usb_isr)
+    usb_isr();
+}
+void USB_SetHandler(void (*new_usb_isr)(void))
+{
+  usb_isr = new_usb_isr;
+}

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/wiring_analog.c

r175	r224
31	31	static int DAC_RESOLUTION = 10;
32	32
33		~~// Wait for synchronization of registers between the clock domains~~
34		~~static __inline__ void syncDAC() __attribute__((always_inline, unused));~~
35		~~static void syncDAC() {~~
36		~~while (DAC->STATUS.bit.SYNCBUSY == 1)~~
37		;
38		}
39
40	33	void analogReadResolution(int res) {
41	34	_readResolution = res;
42	35	while( ADC->STATUS.bit.SYNCBUSY == 1 )
43	36	{
44		// Waiting for synchroinization
	37	// Waiting for synchronization
45	38	}
46	39	if(res == 8) ADC->CTRLB.bit.RESSEL= ADC_CTRLB_RESSEL_8BIT_Val;
…	…
69	62	while( ADC->STATUS.bit.SYNCBUSY == 1 )
70	63	{
71		// Waiting for synchroinization
	64	// Waiting for synchronization
72	65	}
73	66	switch(ulMode)
…	…
91	84	while( ADC->STATUS.bit.SYNCBUSY == 1 )
92	85	{
93		// Waiting for synchroinization
	86	// Waiting for synchronization
94	87	}
95	88	}
…	…
154	147	DAC->DATA.reg = ulValue & 0x3FF; // Dac on 10 bits.
155	148	DAC->CTRLA.bit.ENABLE = 1; // DAC Enabled
156		~~syncDAC();~~
	149	while (DAC->STATUS.bit.SYNCBUSY == 1); //wait for synchronization
157	150	return;
158	151	}

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/cores/arduino/wiring_digital.c

r136	r224
178	178
179	179	default:
	180	PORT->Group[g_APinDescription[ulPin].ulPort].OUTSET.reg = (1ul << g_APinDescription[ulPin].ulPin) ;
180	181	break ;
181	182	}

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/libraries/SPI/SPI.cpp

-              r136
+              r224
 #include "assert.h"
 #include "variant.h"
+#include <Arduino.h>
 SPIClass::SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI)
 …
+}
+void SPIClass::beginSlave()
+{
+  // PIO init
+  pinPeripheral(_uc_pinMiso, g_APinDescription[_uc_pinMiso].ulPinType);
+  pinPeripheral(_uc_pinSCK, g_APinDescription[_uc_pinSCK].ulPinType);
+  pinPeripheral(_uc_pinMosi, g_APinDescription[_uc_pinMosi].ulPinType);
+        // Default speed set to 4Mhz, SPI mode set to MODE 0 and Bit order set to MSB first.
+        _p_sercom->initSPIslave(SPI_PAD_2_SCK_3, SERCOM_RX_PAD_0, SPI_CHAR_SIZE_8_BITS, MSB_FIRST);
+        _p_sercom->enableSPI();
+}
 void SPIClass::end()
+{
         _p_sercom->resetSPI();
+}
+void SPIClass::beginTransaction(SPISettings settings)
+        {
+                SercomDataOrder bitOrder;
+                SercomSpiClockMode SpiClockMode;
+                interruptSave = intStatus();
+                noInterrupts();
+                if(settings.bit_order==LSBFIRST) bitOrder = LSB_FIRST;
+                else if(settings.bit_order==MSBFIRST) bitOrder = MSB_FIRST;
+                else;
+                if(settings.data_mode==SPI_MODE0) SpiClockMode = SERCOM_SPI_MODE_0;
+                else if(settings.data_mode==SPI_MODE1) SpiClockMode = SERCOM_SPI_MODE_1;
+                else if(settings.data_mode==SPI_MODE2) SpiClockMode = SERCOM_SPI_MODE_2;
+                else if(settings.data_mode==SPI_MODE3) SpiClockMode = SERCOM_SPI_MODE_3;
+                else;
+                end();
+                pinPeripheral(_uc_pinMiso, g_APinDescription[_uc_pinMiso].ulPinType);
+                pinPeripheral(_uc_pinSCK, g_APinDescription[_uc_pinSCK].ulPinType);
+                pinPeripheral(_uc_pinMosi, g_APinDescription[_uc_pinMosi].ulPinType);
+                _p_sercom->initSPI(SPI_PAD_2_SCK_3, SERCOM_RX_PAD_0, SPI_CHAR_SIZE_8_BITS, bitOrder);
+                _p_sercom->initSPIClock(SpiClockMode, settings.interface_clock);
+        _p_sercom->enableSPI();
+        inTransactionFlag=1;
+        }
+void SPIClass::endTransaction(void)
+{
+        inTransactionFlag=0;
+        interrupts();
+}
 void SPIClass::setBitOrder(BitOrder order)
 …
+}
 void SPIClass::setClockDivider(uint8_t div)
+void SPIClass::setClockDivider(uint16_t div)
+{
         _p_sercom->setBaudrateSPI(div);
 …
+}
+byte SPIClass::read()
+{
+        return _p_sercom->readDataSPI();
+}
+void SPIClass::usingInterrupt(uint8_t intNum)
+{
+        uint8_t irestore;
+        uint32_t mask;
+        irestore=intStatus();
+        noInterrupts();
+        if(intNum > 13)
+        {
+                //Interrupts();
+                return;
+        }
+        else
+        {
+                //Pio *pio=g_APinDescription[intNum].ulPort;
+                mask=g_APinDescription[intNum].ulPin;
+                interruptMode=1;
+                interruptMask=mask;
+        }
+        if (irestore) interrupts();
+}
+void SPIClass::write(uint8_t data)
+{
+        //Writing the data
+        _p_sercom->writeDataSPI(data);
+}
+void SPIClass::transfer(void *data, size_t count)
+{
+        uint8_t *p;
+        //int i=0;
+                //Serial.println("dentro transfer");
+        if(count==0) return;
+        p=(uint8_t *)data;
+        _p_sercom->writeDataSPI(*p);  //scrittura primo dato
+        while(--count > 0)
+        {
+                //Serial.println("dentro while");
+                uint8_t out=*(p+1); //copio in out il prossimo dato
+                uint8_t in = _p_sercom->readDataSPI();  //leggo dato da SPI
+                //Serial.println("UNO");
+                //while(!(SERCOM4->SPI.INTFLAG.bit.RXC));  // controllo trasferimento  //vedere se necessario
+                //Serial.println("DUE");
+                //Serial.println(out);
+                _p_sercom->writeDataSPI(out);   //scrivo il out su SPI
+                *p++=in; //metto in p il dato letto da spi
+        }
+        while(!(SERCOM4->SPI.INTFLAG.bit.TXC));  // controllo trasferimrnto
+        //Serial.print("*p: ");
+        //Serial.println(*p);
+        *p = _p_sercom->readDataSPI();
+}
+uint16_t SPIClass::transfer16(uint16_t data)
+{
+        union{
+                uint16_t value;
+                struct{
+                        uint8_t lsb;
+                        uint8_t msb;
+                };
+        }in, out;
+        in.value = data;
+        if(SERCOM4->SPI.CTRLA.bit.DORD==0)
+        {
+                _p_sercom->writeDataSPI(in.msb);
+                while(!(SERCOM4->SPI.INTFLAG.bit.TXC));
+                out.msb = _p_sercom->readDataSPI();
+                //while(!(SERCOM4->SPI.INTFLAG.bit.RXC));
+                _p_sercom->writeDataSPI(in.lsb);
+                while(!(SERCOM4->SPI.INTFLAG.bit.TXC));
+                out.lsb = _p_sercom->readDataSPI();
+        }
+        else
+        {
+                _p_sercom->writeDataSPI(in.lsb);
+                while(!(SERCOM4->SPI.INTFLAG.bit.TXC));
+                out.lsb = _p_sercom->readDataSPI();
+                //while(!(SERCOM4->SPI.INTFLAG.bit.RXC));
+                _p_sercom->writeDataSPI(in.msb);
+                while(!(SERCOM4->SPI.INTFLAG.bit.TXC));
+                out.msb = _p_sercom->readDataSPI();
+        }
+                return out.value;
+}
 void SPIClass::attachInterrupt() {
         // Should be enableInterrupt()

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/libraries/SPI/SPI.h

-              r136
+              r224
 #include "variant.h"
 #include "wiring_constants.h"
+#include <Arduino.h>
+//#define LSBFIRST 0 //already defined in wiring_constants.h
+//#define MSBFIRST 1
 #define SPI_MODE0 0x02
 …
 #define SPI_MODE3 0x01
+#define SPI_CLOCK_DIV2 6       //8 MHz
+#define SPI_CLOCK_DIV4 12      //4 MHz
+#define SPI_CLOCK_DIV8 24      //2 MHz
+#define SPI_CLOCK_DIV16 48     //1 MHz
+#define SPI_CLOCK_DIV32 96     //500 KHz
+#define SPI_CLOCK_DIV64 192    //250 KHz
+#define SPI_CLOCK_DIV128 384   //125 KHz
+#ifndef intStatus
+#define intStatus() __intStatus()
+static inline unsigned char __intStatus(void) __attribute__((always_inline, unused));
+static inline unsigned char __intStatus(void) {
+        unsigned int primask, faultmask;
+        asm volatile ("mrs %0, primask" : "=r" (primask));
+        if (primask) return 0;
+        asm volatile ("mrs %0, faultmask" : "=r" (faultmask));
+        if (faultmask) return 0;
+        return 1;
+}
+#endif
+class SPISettings {
+        public:
+                SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode)
+                {
+                        interface_clock = clock;
+                        bit_order = bitOrder;
+                        data_mode = dataMode;
+                        /*Serial.print("clock: ");
+                        Serial.println(interface_clock);
+                        Serial.print("bit order: ");
+                        Serial.println(bit_order);
+                        Serial.print("data mode: ");
+                        Serial.println(data_mode);*/
+                }
+                SPISettings(void)
+                {
+                        interface_clock = 4000000;
+                        bit_order = MSBFIRST;
+                        data_mode = SPI_MODE0;
+                        /*Serial.print("clock: ");
+                        Serial.println(interface_clock);
+                        Serial.print("bit order: ");
+                        Serial.println(bit_order);
+                        Serial.print("data mode: ");
+                        Serial.println(data_mode);*/
+                }
+        private:
+                uint32_t interface_clock;
+                uint8_t bit_order;
+                uint8_t data_mode;
+        friend class SPIClass;
+};
 class SPIClass {
   public:
 …
         byte transfer(uint8_t data);
+        void transfer(void *data, size_t count);
+        byte read(void);
+        uint16_t transfer16(uint16_t data);
+        void write(uint8_t data);
         // SPI Configuration methods
+        void beginTransaction(SPISettings settings);
+        void endTransaction(void);
         void attachInterrupt();
         void detachInterrupt();
+        void usingInterrupt(uint8_t interruptNumber);
         void begin();
+        void beginSlave();
         void end();
         void setBitOrder(BitOrder order);
         void setDataMode(uint8_t uc_mode);
         void setClockDivider(uint8_t uc_div);
+        void setClockDivider(uint16_t uc_div);
   private:
 …
         uint8_t _uc_pinMosi;
         uint8_t _uc_pinSCK;
+        uint8_t interruptMode;
+        uint32_t interruptMask;
+        uint8_t interruptSave;
+        uint8_t inTransactionFlag;
 };

rtos_arduino/trunk/arduino_lib/hardware/arduino/samd/programmers.txt

r136	r224
1		zeroedbg.name=~~M0 Pro~~ Programming Port
	1	zeroedbg.name=Atmel EDBG Programming Port
2	2	zeroedbg.program.tool=openocd

rtos_arduino/trunk/arduino_lib/libraries/Ciao/examples/CiaoRestClient/CiaoRestClient.ino

-              r175
+              r224
 #define CONNECTOR     "rest"
 #define SERVER_ADDR   "192.168.0.100" // change ip address with your server ip address
+#define SERVER_ADDR   "192.168.1.1" // change ip address with your server ip address
 int buttonState = LOW; //this variable tracks the state of the button, low if not pressed, high if pressed
 int ledState = -1; //this variable tracks the state of the LED, negative if off, positive if on
+int buttonState; //this variable tracks the state of the button, low if not pressed, high if pressed
+int ledState = HIGH; //this variable tracks the state of the LED, negative if off, positive if on
 long lastDebounceTime = 0;  // the last time the output pin was toggled
 long debounceDelay = 50;    // the debounce time; increase if the output flickers
+String command = "/arduino/mode/13/output";
+int previous_value = LOW;
 void setup() {
   Ciao.begin();
+  Ciao.write(CONNECTOR, SERVER_ADDR, command);
   pinMode(2, INPUT);
 …
   //sample the state of the button - is it pressed or not?
   buttonState = digitalRead(2);
   //filter out any noise by setting a time buffer
+  if ( (millis() - lastDebounceTime) > debounceDelay) {
+    //if the button has been pressed, lets toggle the LED from "off to on" or "on to off"
+    if ( (buttonState == HIGH) && (ledState < 0) ) {
+      CiaoData data = Ciao.write(CONNECTOR, SERVER_ADDR, "/arduino/digital/12/1"); //turn LED on
+      ledState = -ledState; //now the LED is on, we need to change the state
+      lastDebounceTime = millis(); //set the current time
+  if ( (buttonState == HIGH) && (previous_value == LOW) && (millis() - lastDebounceTime) > debounceDelay ) {
+    if (ledState == HIGH){
+      command = "/arduino/digital/13/0";
+      ledState = LOW;
+    }
+    else if ( (buttonState == HIGH) && (ledState > 0) ) {
+      CiaoData data = Ciao.write(CONNECTOR, SERVER_ADDR, "/arduino/digital/12/0"); //turn LED off
+      ledState = -ledState; //now the LED is off, we need to change the state
+      lastDebounceTime = millis(); //set the current time
+      if (!data.isEmpty()){
+        Ciao.println( "State: " + String (data.get(1)) );
+        Ciao.println( "Response: " + String (data.get(2)) );
+      }
+      else{
+        Ciao.println ("Write Error");
+      }
+    else{
+      command = "/arduino/digital/13/1";
+      ledState = HIGH;
+    }
+    lastDebounceTime = millis(); //set the current time
+    CiaoData data = Ciao.write(CONNECTOR, SERVER_ADDR, command);
+    if (!data.isEmpty()){
+      Ciao.println( "State: " + String (data.get(1)) );
+      Ciao.println( "Response: " + String (data.get(2)) );
+    }
+    else{
+      Ciao.println ("Write Error");
+    }
+  }
+  previous_value = buttonState;
+}

rtos_arduino/trunk/arduino_lib/libraries/Ciao/examples/CiaoRestServer/CiaoRestServer.ino

-              r175
+              r224
 /*
+ This sketch uses the xmpp connector to receive command for the MCU from a xmpp client.
+ This sketch uses the restserver connector receive rest calls. It allows access to
+ the analog and digital pin of the board via rest calls.
+ supported boards: Yun,Tian.
  Possible commands to send from the xmpp client:
+ * "digital/PIN"        -> to read a digital PIN
+ * "digital/PIN/VALUE"  -> to write a digital PIN (VALUE: 1/0)
+ * "analog/PIN/VALUE"   -> to write in a PWM PIN(VALUE range: 0 - 255);
+ * "analog/PIN"         -> to read a analog PIN
+ * "servo/PIN/VALUE"      -> to write angle in a SERVO PIN(VALUE range: 0 - 180);
+ * "mode/PIN/VALUE"     -> to set the PIN mode (VALUE: input / output)
+ * "ledon"              -> turn on led 13
+ * "ledoff"             -> turn off led 13
+ * "ciao"               -> random answers in 5 different languages
+ NOTE: be sure to activate and configure xmpp connector on Linino OS
+       http://labs.arduino.org/Ciao
+ * "/arduino/digital/PIN"       -> to read a digital PIN
+ * "/arduino/digital/PIN/VALUE" -> to write a digital PIN (VALUE: 1/0)
+ * "/arduino/analog/PIN/VALUE"  -> to write in a PWM PIN(VALUE range: 0 - 255);
+ * "/arduino/analog/PIN"        -> to read a analog PIN
+ * "/arduino/servo/PIN/VALUE"   -> to write angle in a SERVO PIN(VALUE range: 0 - 180);
+ * "/arduino/mode/PIN/VALUE"    -> to set the PIN mode (VALUE: input / output)
+ Example:
+ "/arduino/mode/13/output" -> pinMode(13, OUTPUT)
+ "/arduino/digital/13/1"     -> digitalWrite(13, HIGH)
+ NOTE: be sure to activate and configure restserver connector on Linino OS
+  http://labs.arduino.org/Ciao
  created September 2015
  by andrea[at]arduino[dot]org
  */
 #include <Ciao.h>
 #include <Servo.h>
 …
 void loop() {
   CiaoData data = Ciao.read("restserver");
   if(!data.isEmpty()){
+  CiaoData data = Ciao.read("restserver");
+  if(!data.isEmpty()){
     String id = data.get(0);
     String sender = data.get(1);
     String message = data.get(2);
     message.toUpperCase();
     String command[3];
     splitString(message,"/",command,3);
     execute(command,id);
 …
 void servoCommand(String cmd[], String id){
    int pin, value;
   pin = (cmd[1]).toInt();
   if (cmd[2] != "-1") {
     value = (cmd[2]).toInt();
 …
+  }
   else
     Ciao.writeResponse("restserver",id,"Invalid command");
+    Ciao.writeResponse("restserver",id,"Invalid command");
+}
 void digitalCommand(String cmd[], String id) {
   int pin, value;
   pin = (cmd[1]).toInt();
   if (cmd[2] != "-1") {
     value = (cmd[2]).toInt();
 …
       Ciao.writeResponse("restserver",id,"Pin D"+String(pin)+" ON");
     else if(value == 0)
       Ciao.writeResponse("restserver",id,"Pin D"+String(pin)+" OFF");
+      Ciao.writeResponse("restserver",id,"Pin D"+String(pin)+" OFF");
+  }
   else if (cmd[2] == "-1") {
 …
   pin = (cmd[1]).toInt();
   if (cmd[2] != "-1") {
     value =(cmd[2]).toInt();
 …
   pin = (cmd[1]).toInt();
   if (cmd[2] == "INPUT") {
     pinMode(pin, INPUT);

rtos_arduino/trunk/arduino_lib/libraries/Ciao/keywords.txt

-              r175
+              r224
 #######################################
 Ciao            KEYWORD3
 CiaoData        KEYWORD3
 Wifi            KEYWORD3
 WifiData        KEYWORD3
+Ciao  KEYWORD3
+CiaoData  KEYWORD3
+Wifi  KEYWORD3
+WifiData  KEYWORD3
 #######################################
 …
 #######################################
+begin                   KEYWORD2
+writeResponse   KEYWORD2
+available               KEYWORD2
+read                    KEYWORD2
+write                   KEYWORD2
+bool                    KEYWORD2
+writeResponse KEYWORD2
+available KEYWORD2
+read  KEYWORD2
+write KEYWORD2
+#######################################
+# Constants (LITERAL1)
+#######################################

rtos_arduino/trunk/arduino_lib/libraries/Ciao/library.properties

r175	r224
1	1	name=Ciao
2		version=~~1.0~~
	2	version=0.0.3
3	3	author=Arduino srl
4	4	maintainer=Arduino srl<info@arduino.org>

rtos_arduino/trunk/arduino_lib/libraries/Ciao/src/Ciao.h

-              r175
+              r224
 #include <Arduino.h>
+#include <Stream.h>
 #include "lib/CiaoData.h"
 #if defined(__AVR_ATmega328P__)
-#include "lib/rest.h"
 #include "lib/SC16IS750.h"
-#include "lib/espduino.h"
-#else
-#include <Stream.h>
 #endif
 …
 #define BAUDRATE 250000
 #elif defined(ARDUINO_ARCH_SAMD)
 #define BAUDRATE 115200
+#define BAUDRATE 4000000
 #endif
 …
                 CiaoData parse( String, String);
                 void println(String log){};
-                #if defined(__AVR_ATmega32U4__)
                 CiaoClass(Stream &_stream);
-                #elif defined(ARDUINO_ARCH_SAMD)
-                CiaoClass(Serial_ stream);
-                #endif
         private:
                 void dropAll();
                 bool started;
-                #if defined(__AVR_ATmega32U4__)
                 Stream &stream;
-                #elif defined(ARDUINO_ARCH_SAMD)
-                Serial_ stream;
-                #endif
 };
 …
+                }
                 #elif defined(ARDUINO_ARCH_SAMD)
                 SerialCiaoClass(Serial_ serial)
                         : CiaoClass(serial){
                         // Empty
+                SerialCiaoClass(Serial_ &_serial)
+                        : CiaoClass(_serial), serial(_serial) {
+                        // Empty
+                }
                 #endif
 …
                 HardwareSerial &serial;
                 #elif defined(ARDUINO_ARCH_SAMD)
                 Serial_ serial;
+                Serial_ &serial;
                 #endif
 };
 …
 #else
+// class CiaoData {
+//      public:
+//              char* get(int index){
+//                      return msg_split[index];
+//              }
+//      public:
+//              char* msg_split[3];
+// };
+class ArduinoWifiClass : public WifiData
+{
+class CiaoClass {
+        public:
+                void begin();
+                boolean connected();
+                void connect(char* , char*);
+                void powerON();
+                void powerOFF();
+};
+class CiaoClass : public WifiData
+{
         public:
                 void begin();
 …
                 CiaoData write( char*, char*, String );            // ârestâ, âhostnameâ, âStringoneâ,
                 CiaoData write( char*, char*, String, char*);      // ârestâ, âhostnameâ, âStringoneâ, âmethodâ
-                void print(String str);
-                void println(String str);
 };
 extern CiaoClass Ciao;
+extern ArduinoWifiClass Wifi;
 #endif

rtos_arduino/trunk/arduino_lib/libraries/Ciao/src/lib/Ciao.cpp

-              r175
+              r224
 */
-#include "Ciao.h"
 #if defined(__AVR_ATmega32U4__) || defined(ARDUINO_ARCH_SAMD)
+#if defined(__AVR_ATmega32U4__)
+#include "Ciao.h"
 CiaoClass::CiaoClass(Stream &_stream) :
         stream(_stream), started(false) {
   // Empty
+}
-#elif defined(ARDUINO_ARCH_SAMD)
-CiaoClass::CiaoClass(Serial_ stream){
-  // Empty
+}
-#endif
 void CiaoClass::begin() {
 …
+    }
         do{
-                #if defined(__AVR_ATmega32U4__)
                 stream.print(F("run-ciao\n"));                          //start bridge python
                 stream.readStringUntil(END_TX_CHAR);
-                #endif
                 delay(3000);
                 stream.println("ciao;r;status");                                //check if bridge python is running

rtos_arduino/trunk/arduino_lib/libraries/Ciao/src/lib/SC16IS750.cpp

-              r175
+              r224
 #define WIRE Wire
+WifiData::WifiData(uint8_t prtcl, uint8_t addr_sspin)
+{
+    protocol = prtcl;
+    if ( protocol == SC16IS750_PROTOCOL_I2C ) {
+        device_address_sspin = (addr_sspin>>1);
+    } else {
+        device_address_sspin = addr_sspin;
+    }
+WifiData::WifiData()
+{
+    device_address_sspin = (SC16IS750_ADDRESS_AA >> 1);
     peek_flag = 0;
+}
 …
 void WifiData::begin(uint32_t baud)
+{
+    //Serial.println("1111111111111111");
     if ( protocol == SC16IS750_PROTOCOL_I2C) {
-    //Serial.println("22222222222222");
         WIRE.begin();
+    }

rtos_arduino/trunk/arduino_lib/libraries/Ciao/src/lib/SC16IS750.h

-              r175
+              r224
 #define     SC16IS750_PROTOCOL_I2C  (0)
 #define     SC16IS750_PROTOCOL_I2C  (0)
+#define     END     "<!--~-->"
+#define     DELIMITER     "<!--~-->"
+#define     EOL           '\0'
 class WifiData : public Stream
+{
     public:
         WifiData(uint8_t prtcl = SC16IS750_PROTOCOL_I2C, uint8_t addr = SC16IS750_ADDRESS_AD);
+        WifiData();
         void begin(uint32_t baud);
         int read();

rtos_arduino/trunk/arduino_lib/libraries/Ciao/src/lib/espduino.cpp

r175	r224
188	188	}
189	189
190		ESP::ESP(Stream *serial~~, int chip_pd~~):
191		_serial(serial)~~, _chip_pd(chip_pd)~~
	190	ESP::ESP(Stream *serial):
	191	_serial(serial)
192	192	{
193	193	_debugEn = false;
…	…
195	195	}
196	196
197		ESP::ESP(Stream serial, Stream debug, int chip_pd):
198		_serial(serial), _debug(debug), _chip_pd(chip_pd)
199		{
200		_debugEn = true;
201		//_serial = _debug;
202		init();
203		}
	197
204	198	void ESP::enable()
205	199	{

rtos_arduino/trunk/arduino_lib/libraries/Ciao/src/lib/espduino.h

-              r175
+              r224
+{
 public:
   ESP(Stream *serial, Stream* debug, int chip_pd);
   ESP(Stream *serial, int chip_pd);
+  //ESP(Stream *serial, Stream* debug, int chip_pd);
+  ESP(Stream *serial); //ok
   Stream *_debug;

rtos_arduino/trunk/arduino_lib/libraries/Firmata/examples/AllInputsFirmata/AllInputsFirmata.ino

-              r136
+              r224
 int previousAnalogValues[TOTAL_ANALOG_PINS];
 byte portStatus[TOTAL_PORTS];   // each bit: 1=pin is digital input, 0=other/ignore
+byte portStatus[TOTAL_PORTS]; // each bit: 1=pin is digital input, 0=other/ignore
 byte previousPINs[TOTAL_PORTS];
 …
   byte i, port, status;
   Firmata.setFirmwareVersion(0, 1);
+  Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
   for (pin = 0; pin < TOTAL_PINS; pin++) {

rtos_arduino/trunk/arduino_lib/libraries/Firmata/examples/AnalogFirmata/AnalogFirmata.ino

r136	r224
54	54	{
55	55	if (value == 0) {
56		analogInputsToReport = analogInputsToReport &~ (1 << pin);
	56	analogInputsToReport = analogInputsToReport & ~ (1 << pin);
57	57	}
58	58	else { // everything but 0 enables reporting of that pin
…	…
67	67	void setup()
68	68	{
69		Firmata.setFirmwareVersion(~~0, 2~~);
	69	Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
70	70	Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
71	71	Firmata.attach(REPORT_ANALOG, reportAnalogCallback);

rtos_arduino/trunk/arduino_lib/libraries/Firmata/examples/EchoString/EchoString.ino

-              r136
+              r224
 void sysexCallback(byte command, byte argc, byte*argv)
+void sysexCallback(byte command, byte argc, byte *argv)
+{
   Firmata.sendSysex(command, argc, argv);
 …
 void setup()
+{
   Firmata.setFirmwareVersion(0, 1);
+  Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
   Firmata.attach(STRING_DATA, stringCallback);
   Firmata.attach(START_SYSEX, sysexCallback);

rtos_arduino/trunk/arduino_lib/libraries/Firmata/examples/OldStandardFirmata/OldStandardFirmata.ino

-              r136
+              r224
 void outputPort(byte portNumber, byte portValue)
+{
   portValue = portValue &~ portStatus[portNumber];
+  portValue = portValue & ~ portStatus[portNumber];
   if (previousPINs[portNumber] != portValue) {
     Firmata.sendDigitalPort(portNumber, portValue);
 …
     if (reportPINs[i]) {
       switch (i) {
         case 0: outputPort(0, PIND &~ B00000011); break; // ignore Rx/Tx 0/1
+        case 0: outputPort(0, PIND & ~ B00000011); break; // ignore Rx/Tx 0/1
         case 1: outputPort(1, PINB); break;
         case 2: outputPort(2, PINC); break;
 …
       case INPUT:
         pinMode(pin, INPUT);
         portStatus[port] = portStatus[port] &~ (1 << (pin - offset));
+        portStatus[port] = portStatus[port] & ~ (1 << (pin - offset));
         break;
       case OUTPUT:
 …
         portStatus[port] = portStatus[port] | (1 << (pin - offset));
         break;
         //case ANALOG: // TODO figure this out
+      //case ANALOG: // TODO figure this out
       default:
         Firmata.sendString("");
 …
 void analogWriteCallback(byte pin, int value)
+{
   setPinModeCallback(pin, PWM);
+  setPinModeCallback(pin, PIN_MODE_PWM);
   analogWrite(pin, value);
+}
 …
     case 0: // pins 2-7 (don't change Rx/Tx, pins 0 and 1)
       // 0xFF03 == B1111111100000011    0x03 == B00000011
       PORTD = (value &~ 0xFF03) | (PORTD & 0x03);
+      PORTD = (value & ~ 0xFF03) | (PORTD & 0x03);
       break;
     case 1: // pins 8-13 (14,15 are disabled for the crystal)
 …
+{
   if (value == 0) {
     analogInputsToReport = analogInputsToReport &~ (1 << pin);
+    analogInputsToReport = analogInputsToReport & ~ (1 << pin);
+  }
   else { // everything but 0 enables reporting of that pin
 …
    * host computer, since once in the loop(), this firmware will only send
    * digital data on change. */
   if (reportPINs[0]) outputPort(0, PIND &~ B00000011); // ignore Rx/Tx 0/1
+  if (reportPINs[0]) outputPort(0, PIND & ~ B00000011); // ignore Rx/Tx 0/1
   if (reportPINs[1]) outputPort(1, PINB);
   if (reportPINs[2]) outputPort(2, PINC);

rtos_arduino/trunk/arduino_lib/libraries/Firmata/examples/ServoFirmata/ServoFirmata.ino

-              r136
+              r224
  * included in Arduino 0017
+ *
- * TODO add message to configure minPulse/maxPulse/degrees
+ *
  * This example code is in the public domain.
  */
 …
 Servo servos[MAX_SERVOS];
+byte servoPinMap[TOTAL_PINS];
+byte servoCount = 0;
 void analogWriteCallback(byte pin, int value)
+{
   if (IS_PIN_SERVO(pin)) {
     servos[PIN_TO_SERVO(pin)].write(value);
+  if (IS_PIN_DIGITAL(pin)) {
+    servos[servoPinMap[pin]].write(value);
+  }
+}
+void systemResetCallback()
+{
+  servoCount = 0;
+}
 …
   byte pin;
   Firmata.setFirmwareVersion(0, 2);
+  Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
   Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
+  Firmata.attach(SYSTEM_RESET, systemResetCallback);
+  Firmata.begin(57600);
+  systemResetCallback();
+  // attach servos from first digital pin up to max number of
+  // servos supported for the board
   for (pin = 0; pin < TOTAL_PINS; pin++) {
+    if (IS_PIN_SERVO(pin)) {
+      servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin));
+    if (IS_PIN_DIGITAL(pin)) {
+      if (servoCount < MAX_SERVOS) {
+        servoPinMap[pin] = servoCount;
+        servos[servoPinMap[pin]].attach(PIN_TO_DIGITAL(pin));
+        servoCount++;
+      }
+    }
+  }
-  Firmata.begin(57600);
+}
 …
     Firmata.processInput();
+}

rtos_arduino/trunk/arduino_lib/libraries/Firmata/examples/SimpleAnalogFirmata/SimpleAnalogFirmata.ino

r136	r224
28	28	void setup()
29	29	{
30		Firmata.setFirmwareVersion(~~0, 1~~);
	30	Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
31	31	Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
32	32	Firmata.begin(57600);

rtos_arduino/trunk/arduino_lib/libraries/Firmata/examples/SimpleDigitalFirmata/SimpleDigitalFirmata.ino

r136	r224
53	53	void setup()
54	54	{
55		Firmata.setFirmwareVersion(~~0, 1~~);
	55	Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
56	56	Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
57	57	Firmata.attach(SET_PIN_MODE, setPinModeCallback);

rtos_arduino/trunk/arduino_lib/libraries/Firmata/examples/StandardFirmata/StandardFirmata.ino

-              r136
+              r224
 /*
+ * Firmata is a generic protocol for communicating with microcontrollers
+ * from software on a host computer. It is intended to work with
+ * any host computer software package.
+ *
+ * To download a host software package, please clink on the following link
+ * to open the download page in your default browser.
+ *
+ * http://firmata.org/wiki/Download
+ */
+/*
+  Firmata is a generic protocol for communicating with microcontrollers
+  from software on a host computer. It is intended to work with
+  any host computer software package.
+  To download a host software package, please clink on the following link
+  to open the list of Firmata client libraries your default browser.
+  https://github.com/firmata/arduino#firmata-client-libraries
   Copyright (C) 2006-2008 Hans-Christoph Steiner.  All rights reserved.
   Copyright (C) 2010-2011 Paul Stoffregen.  All rights reserved.
   Copyright (C) 2009 Shigeru Kobayashi.  All rights reserved.
   Copyright (C) 2009-2011 Jeff Hoefs.  All rights reserved.
+  Copyright (C) 2009-2016 Jeff Hoefs.  All rights reserved.
   This library is free software; you can redistribute it and/or
 …
   See file LICENSE.txt for further informations on licensing terms.
   formatted using the GNU C formatting and indenting
+  Last updated by Jeff Hoefs: January 10th, 2016
 */
-/*
- * TODO: use Program Control to load stored profiles from EEPROM
- */
 #include <Servo.h>
 …
 #include <Firmata.h>
+// move the following defines to Firmata.h?
+#define I2C_WRITE B00000000
+#define I2C_READ B00001000
+#define I2C_READ_CONTINUOUSLY B00010000
+#define I2C_STOP_READING B00011000
+#define I2C_READ_WRITE_MODE_MASK B00011000
+#define I2C_WRITE                   B00000000
+#define I2C_READ                    B00001000
+#define I2C_READ_CONTINUOUSLY       B00010000
+#define I2C_STOP_READING            B00011000
+#define I2C_READ_WRITE_MODE_MASK    B00011000
 #define I2C_10BIT_ADDRESS_MODE_MASK B00100000
+#define MAX_QUERIES 8
+#define MINIMUM_SAMPLING_INTERVAL 10
+#define REGISTER_NOT_SPECIFIED -1
+#define I2C_END_TX_MASK             B01000000
+#define I2C_STOP_TX                 1
+#define I2C_RESTART_TX              0
+#define I2C_MAX_QUERIES             8
+#define I2C_REGISTER_NOT_SPECIFIED  -1
+// the minimum interval for sampling analog input
+#define MINIMUM_SAMPLING_INTERVAL   1
 /*==============================================================================
 …
  *============================================================================*/
+#ifdef FIRMATA_SERIAL_FEATURE
+SerialFirmata serialFeature;
+#endif
 /* analog inputs */
 int analogInputsToReport = 0; // bitwise array to store pin reporting
 …
 /* pins configuration */
-byte pinConfig[TOTAL_PINS];         // configuration of every pin
 byte portConfigInputs[TOTAL_PORTS]; // each bit: 1 = pin in INPUT, 0 = anything else
-int pinState[TOTAL_PINS];           // any value that has been written
 /* timer variables */
 unsigned long currentMillis;        // store the current value from millis()
 unsigned long previousMillis;       // for comparison with currentMillis
 int samplingInterval = 19;          // how often to run the main loop (in ms)
+unsigned int samplingInterval = 19; // how often to run the main loop (in ms)
 /* i2c data */
 struct i2c_device_info {
   byte addr;
   byte reg;
+  int reg;
   byte bytes;
+  byte stopTX;
 };
 /* for i2c read continuous more */
 i2c_device_info query[MAX_QUERIES];
 byte i2cRxData[32];
+i2c_device_info query[I2C_MAX_QUERIES];
+byte i2cRxData[64];
 boolean isI2CEnabled = false;
 signed char queryIndex = -1;
+unsigned int i2cReadDelayTime = 0;  // default delay time between i2c read request and Wire.requestFrom()
+// default delay time between i2c read request and Wire.requestFrom()
+unsigned int i2cReadDelayTime = 0;
 Servo servos[MAX_SERVOS];
+byte servoPinMap[TOTAL_PINS];
+byte detachedServos[MAX_SERVOS];
+byte detachedServoCount = 0;
+byte servoCount = 0;
+boolean isResetting = false;
+/* utility functions */
+void wireWrite(byte data)
+{
+#if ARDUINO >= 100
+  Wire.write((byte)data);
+#else
+  Wire.send(data);
+#endif
+}
+byte wireRead(void)
+{
+#if ARDUINO >= 100
+  return Wire.read();
+#else
+  return Wire.receive();
+#endif
+}
 /*==============================================================================
  * FUNCTIONS
  *============================================================================*/
+void readAndReportData(byte address, int theRegister, byte numBytes) {
+void attachServo(byte pin, int minPulse, int maxPulse)
+{
+  if (servoCount < MAX_SERVOS) {
+    // reuse indexes of detached servos until all have been reallocated
+    if (detachedServoCount > 0) {
+      servoPinMap[pin] = detachedServos[detachedServoCount - 1];
+      if (detachedServoCount > 0) detachedServoCount--;
+    } else {
+      servoPinMap[pin] = servoCount;
+      servoCount++;
+    }
+    if (minPulse > 0 && maxPulse > 0) {
+      servos[servoPinMap[pin]].attach(PIN_TO_DIGITAL(pin), minPulse, maxPulse);
+    } else {
+      servos[servoPinMap[pin]].attach(PIN_TO_DIGITAL(pin));
+    }
+  } else {
+    Firmata.sendString("Max servos attached");
+  }
+}
+void detachServo(byte pin)
+{
+  servos[servoPinMap[pin]].detach();
+  // if we're detaching the last servo, decrement the count
+  // otherwise store the index of the detached servo
+  if (servoPinMap[pin] == servoCount && servoCount > 0) {
+    servoCount--;
+  } else if (servoCount > 0) {
+    // keep track of detached servos because we want to reuse their indexes
+    // before incrementing the count of attached servos
+    detachedServoCount++;
+    detachedServos[detachedServoCount - 1] = servoPinMap[pin];
+  }
+  servoPinMap[pin] = 255;
+}
+void readAndReportData(byte address, int theRegister, byte numBytes, byte stopTX) {
   // allow I2C requests that don't require a register read
   // for example, some devices using an interrupt pin to signify new data available
   // do not always require the register read so upon interrupt you call Wire.requestFrom()
   if (theRegister != REGISTER_NOT_SPECIFIED) {
+  if (theRegister != I2C_REGISTER_NOT_SPECIFIED) {
     Wire.beginTransmission(address);
+#if ARDUINO >= 100
+    Wire.write((byte)theRegister);
+#else
+    Wire.send((byte)theRegister);
+#endif
+    Wire.endTransmission();
+    wireWrite((byte)theRegister);
+    Wire.endTransmission(stopTX); // default = true
     // do not set a value of 0
     if (i2cReadDelayTime > 0) {
 …
   // check to be sure correct number of bytes were returned by slave
+  if (numBytes == Wire.available()) {
+    i2cRxData[0] = address;
+    i2cRxData[1] = theRegister;
+    for (int i = 0; i < numBytes; i++) {
+#if ARDUINO >= 100
+      i2cRxData[2 + i] = Wire.read();
+#else
+      i2cRxData[2 + i] = Wire.receive();
+#endif
+    }
+  }
+  else {
+    if (numBytes > Wire.available()) {
+      Firmata.sendString("I2C Read Error: Too many bytes received");
+    } else {
+      Firmata.sendString("I2C Read Error: Too few bytes received");
+    }
+  if (numBytes < Wire.available()) {
+    Firmata.sendString("I2C: Too many bytes received");
+  } else if (numBytes > Wire.available()) {
+    Firmata.sendString("I2C: Too few bytes received");
+  }
+  i2cRxData[0] = address;
+  i2cRxData[1] = theRegister;
+  for (int i = 0; i < numBytes && Wire.available(); i++) {
+    i2cRxData[2 + i] = wireRead();
+  }
 …
 // -----------------------------------------------------------------------------
+/* disable the i2c pins so they can be used for other functions */
+void disableI2CPins() {
+  isI2CEnabled = false;
+  // disable read continuous mode for all devices
+  queryIndex = -1;
+}
+/* sets bits in a bit array (int) to toggle the reporting of the analogIns
+ */
+//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
+//}
+void reportAnalogCallback(byte analogPin, int value)
+{
+  if (analogPin < TOTAL_ANALOG_PINS) {
+    if (value == 0) {
+      analogInputsToReport = analogInputsToReport & ~ (1 << analogPin);
+    } else {
+      analogInputsToReport = analogInputsToReport | (1 << analogPin);
+      // prevent during system reset or all analog pin values will be reported
+      // which may report noise for unconnected analog pins
+      if (!isResetting) {
+        // Send pin value immediately. This is helpful when connected via
+        // ethernet, wi-fi or bluetooth so pin states can be known upon
+        // reconnecting.
+        Firmata.sendAnalog(analogPin, analogRead(analogPin));
+      }
+    }
+  }
+  // TODO: save status to EEPROM here, if changed
+}
+// -----------------------------------------------------------------------------
 /* sets the pin mode to the correct state and sets the relevant bits in the
  * two bit-arrays that track Digital I/O and PWM status
 …
 void setPinModeCallback(byte pin, int mode)
+{
+  if (pinConfig[pin] == I2C && isI2CEnabled && mode != I2C) {
+  if (Firmata.getPinMode(pin) == PIN_MODE_IGNORE)
+    return;
+  if (Firmata.getPinMode(pin) == PIN_MODE_I2C && isI2CEnabled && mode != PIN_MODE_I2C) {
     // disable i2c so pins can be used for other functions
     // the following if statements should reconfigure the pins properly
     disableI2CPins();
+  }
+  if (IS_PIN_SERVO(pin) && mode != SERVO && servos[PIN_TO_SERVO(pin)].attached()) {
+    servos[PIN_TO_SERVO(pin)].detach();
+  if (IS_PIN_DIGITAL(pin) && mode != PIN_MODE_SERVO) {
+    if (servoPinMap[pin] < MAX_SERVOS && servos[servoPinMap[pin]].attached()) {
+      detachServo(pin);
+    }
+  }
   if (IS_PIN_ANALOG(pin)) {
     reportAnalogCallback(PIN_TO_ANALOG(pin), mode == ANALOG ? 1 : 0); // turn on/off reporting
+    reportAnalogCallback(PIN_TO_ANALOG(pin), mode == PIN_MODE_ANALOG ? 1 : 0); // turn on/off reporting
+  }
   if (IS_PIN_DIGITAL(pin)) {
     if (mode == INPUT) {
+    if (mode == INPUT || mode == PIN_MODE_PULLUP) {
       portConfigInputs[pin / 8] |= (1 << (pin & 7));
     } else {
 …
+    }
+  }
   pinState[pin] = 0;
+  Firmata.setPinState(pin, 0);
   switch (mode) {
     case ANALOG:
+    case PIN_MODE_ANALOG:
       if (IS_PIN_ANALOG(pin)) {
         if (IS_PIN_DIGITAL(pin)) {
+          pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
+          pinMode(PIN_TO_DIGITAL(pin), INPUT);    // disable output driver
+#if ARDUINO <= 100
+          // deprecated since Arduino 1.0.1 - TODO: drop support in Firmata 2.6
           digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
+        }
+        pinConfig[pin] = ANALOG;
+#endif
+        }
+        Firmata.setPinMode(pin, PIN_MODE_ANALOG);
+      }
       break;
     case INPUT:
       if (IS_PIN_DIGITAL(pin)) {
+        pinMode(PIN_TO_DIGITAL(pin), INPUT); // disable output driver
+        pinMode(PIN_TO_DIGITAL(pin), INPUT);    // disable output driver
+#if ARDUINO <= 100
+        // deprecated since Arduino 1.0.1 - TODO: drop support in Firmata 2.6
         digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
+        pinConfig[pin] = INPUT;
+#endif
+        Firmata.setPinMode(pin, INPUT);
+      }
+      break;
+    case PIN_MODE_PULLUP:
+      if (IS_PIN_DIGITAL(pin)) {
+        pinMode(PIN_TO_DIGITAL(pin), INPUT_PULLUP);
+        Firmata.setPinMode(pin, PIN_MODE_PULLUP);
+        Firmata.setPinState(pin, 1);
+      }
       break;
 …
         digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable PWM
         pinMode(PIN_TO_DIGITAL(pin), OUTPUT);
         pinConfig[pin] = OUTPUT;
+      }
       break;
     case PWM:
+        Firmata.setPinMode(pin, OUTPUT);
+      }
+      break;
+    case PIN_MODE_PWM:
       if (IS_PIN_PWM(pin)) {
         pinMode(PIN_TO_PWM(pin), OUTPUT);
         analogWrite(PIN_TO_PWM(pin), 0);
+        pinConfig[pin] = PWM;
+      }
+      break;
+    case SERVO:
+      if (IS_PIN_SERVO(pin)) {
+        pinConfig[pin] = SERVO;
+        if (!servos[PIN_TO_SERVO(pin)].attached()) {
+          servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin));
+        }
+      }
+      break;
+    case I2C:
+        Firmata.setPinMode(pin, PIN_MODE_PWM);
+      }
+      break;
+    case PIN_MODE_SERVO:
+      if (IS_PIN_DIGITAL(pin)) {
+        Firmata.setPinMode(pin, PIN_MODE_SERVO);
+        if (servoPinMap[pin] == 255 || !servos[servoPinMap[pin]].attached()) {
+          // pass -1 for min and max pulse values to use default values set
+          // by Servo library
+          attachServo(pin, -1, -1);
+        }
+      }
+      break;
+    case PIN_MODE_I2C:
       if (IS_PIN_I2C(pin)) {
         // mark the pin as i2c
         // the user must call I2C_CONFIG to enable I2C for a device
+        pinConfig[pin] = I2C;
+      }
+        Firmata.setPinMode(pin, PIN_MODE_I2C);
+      }
+      break;
+    case PIN_MODE_SERIAL:
+#ifdef FIRMATA_SERIAL_FEATURE
+      serialFeature.handlePinMode(pin, PIN_MODE_SERIAL);
+#endif
       break;
     default:
 …
+}
+/*
+ * Sets the value of an individual pin. Useful if you want to set a pin value but
+ * are not tracking the digital port state.
+ * Can only be used on pins configured as OUTPUT.
+ * Cannot be used to enable pull-ups on Digital INPUT pins.
+ */
+void setPinValueCallback(byte pin, int value)
+{
+  if (pin < TOTAL_PINS && IS_PIN_DIGITAL(pin)) {
+    if (Firmata.getPinMode(pin) == OUTPUT) {
+      Firmata.setPinState(pin, value);
+      digitalWrite(PIN_TO_DIGITAL(pin), value);
+    }
+  }
+}
 void analogWriteCallback(byte pin, int value)
+{
   if (pin < TOTAL_PINS) {
     switch (pinConfig[pin]) {
       case SERVO:
         if (IS_PIN_SERVO(pin))
           servos[PIN_TO_SERVO(pin)].write(value);
         pinState[pin] = value;
+    switch (Firmata.getPinMode(pin)) {
+      case PIN_MODE_SERVO:
+        if (IS_PIN_DIGITAL(pin))
+          servos[servoPinMap[pin]].write(value);
+        Firmata.setPinState(pin, value);
         break;
       case PWM:
+      case PIN_MODE_PWM:
         if (IS_PIN_PWM(pin))
           analogWrite(PIN_TO_PWM(pin), value);
         pinState[pin] = value;
+        Firmata.setPinState(pin, value);
         break;
+    }
 …
 void digitalWriteCallback(byte port, int value)
+{
   byte pin, lastPin, mask = 1, pinWriteMask = 0;
+  byte pin, lastPin, pinValue, mask = 1, pinWriteMask = 0;
   if (port < TOTAL_PORTS) {
 …
       // do not disturb non-digital pins (eg, Rx & Tx)
       if (IS_PIN_DIGITAL(pin)) {
-        // only write to OUTPUT and INPUT (enables pullup)
         // do not touch pins in PWM, ANALOG, SERVO or other modes
+        if (pinConfig[pin] == OUTPUT || pinConfig[pin] == INPUT) {
+          pinWriteMask |= mask;
+          pinState[pin] = ((byte)value & mask) ? 1 : 0;
+        if (Firmata.getPinMode(pin) == OUTPUT || Firmata.getPinMode(pin) == INPUT) {
+          pinValue = ((byte)value & mask) ? 1 : 0;
+          if (Firmata.getPinMode(pin) == OUTPUT) {
+            pinWriteMask |= mask;
+          } else if (Firmata.getPinMode(pin) == INPUT && pinValue == 1 && Firmata.getPinState(pin) != 1) {
+            // only handle INPUT here for backwards compatibility
+#if ARDUINO > 100
+            pinMode(pin, INPUT_PULLUP);
+#else
+            // only write to the INPUT pin to enable pullups if Arduino v1.0.0 or earlier
+            pinWriteMask |= mask;
+#endif
+          }
+          Firmata.setPinState(pin, pinValue);
+        }
+      }
 …
 // -----------------------------------------------------------------------------
-/* sets bits in a bit array (int) to toggle the reporting of the analogIns
- */
-//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
-//}
-void reportAnalogCallback(byte analogPin, int value)
+{
-  if (analogPin < TOTAL_ANALOG_PINS) {
-    if (value == 0) {
-      analogInputsToReport = analogInputsToReport &~ (1 << analogPin);
-    } else {
-      analogInputsToReport = analogInputsToReport | (1 << analogPin);
+    }
+  }
-  // TODO: save status to EEPROM here, if changed
+}
 void reportDigitalCallback(byte port, int value)
 …
   if (port < TOTAL_PORTS) {
     reportPINs[port] = (byte)value;
+    // Send port value immediately. This is helpful when connected via
+    // ethernet, wi-fi or bluetooth so pin states can be known upon
+    // reconnecting.
+    if (value) outputPort(port, readPort(port, portConfigInputs[port]), true);
+  }
   // do not disable analog reporting on these 8 pins, to allow some
 …
+}
+// -----------------------------------------------------------------------------
+void enableI2CPins()
+{
+  byte i;
+  // is there a faster way to do this? would probaby require importing
+  // Arduino.h to get SCL and SDA pins
+  for (i = 0; i < TOTAL_PINS; i++) {
+    if (IS_PIN_I2C(i)) {
+      // mark pins as i2c so they are ignore in non i2c data requests
+      setPinModeCallback(i, PIN_MODE_I2C);
+    }
+  }
+  isI2CEnabled = true;
+  Wire.begin();
+}
 /*==============================================================================
  * SYSEX-BASED commands
 …
+{
   byte mode;
+  byte stopTX;
   byte slaveAddress;
-  byte slaveRegister;
   byte data;
+  int slaveRegister;
   unsigned int delayTime;
 …
       mode = argv[1] & I2C_READ_WRITE_MODE_MASK;
       if (argv[1] & I2C_10BIT_ADDRESS_MODE_MASK) {
         Firmata.sendString("10-bit addressing mode is not yet supported");
+        Firmata.sendString("10-bit addressing not supported");
         return;
+      }
       else {
         slaveAddress = argv[0];
+      }
+      // need to invert the logic here since 0 will be default for client
+      // libraries that have not updated to add support for restart tx
+      if (argv[1] & I2C_END_TX_MASK) {
+        stopTX = I2C_RESTART_TX;
+      }
+      else {
+        stopTX = I2C_STOP_TX; // default
+      }
 …
           for (byte i = 2; i < argc; i += 2) {
             data = argv[i] + (argv[i + 1] << 7);
+#if ARDUINO >= 100
+            Wire.write(data);
+#else
+            Wire.send(data);
+#endif
+            wireWrite(data);
+          }
           Wire.endTransmission();
 …
             slaveRegister = argv[2] + (argv[3] << 7);
             data = argv[4] + (argv[5] << 7);  // bytes to read
-            readAndReportData(slaveAddress, (int)slaveRegister, data);
+          }
           else {
             // a slave register is NOT specified
+            slaveRegister = I2C_REGISTER_NOT_SPECIFIED;
             data = argv[2] + (argv[3] << 7);  // bytes to read
-            readAndReportData(slaveAddress, (int)REGISTER_NOT_SPECIFIED, data);
+          }
+          readAndReportData(slaveAddress, (int)slaveRegister, data, stopTX);
           break;
         case I2C_READ_CONTINUOUSLY:
           if ((queryIndex + 1) >= MAX_QUERIES) {
+          if ((queryIndex + 1) >= I2C_MAX_QUERIES) {
             // too many queries, just ignore
             Firmata.sendString("too many queries");
             break;
+          }
+          if (argc == 6) {
+            // a slave register is specified
+            slaveRegister = argv[2] + (argv[3] << 7);
+            data = argv[4] + (argv[5] << 7);  // bytes to read
+          }
+          else {
+            // a slave register is NOT specified
+            slaveRegister = (int)I2C_REGISTER_NOT_SPECIFIED;
+            data = argv[2] + (argv[3] << 7);  // bytes to read
+          }
           queryIndex++;
           query[queryIndex].addr = slaveAddress;
+          query[queryIndex].reg = argv[2] + (argv[3] << 7);
+          query[queryIndex].bytes = argv[4] + (argv[5] << 7);
+          query[queryIndex].reg = slaveRegister;
+          query[queryIndex].bytes = data;
+          query[queryIndex].stopTX = stopTX;
           break;
         case I2C_STOP_READING:
 …
             queryIndex = -1;
           } else {
+            queryIndexToSkip = 0;
             // if read continuous mode is enabled for multiple devices,
             // determine which device to stop reading and remove it's data from
             // the array, shifiting other array data to fill the space
             for (byte i = 0; i < queryIndex + 1; i++) {
               if (query[i].addr = slaveAddress) {
+              if (query[i].addr == slaveAddress) {
                 queryIndexToSkip = i;
                 break;
 …
             for (byte i = queryIndexToSkip; i < queryIndex + 1; i++) {
               if (i < MAX_QUERIES) {
+              if (i < I2C_MAX_QUERIES) {
                 query[i].addr = query[i + 1].addr;
                 query[i].reg = query[i + 1].addr;
+                query[i].reg = query[i + 1].reg;
                 query[i].bytes = query[i + 1].bytes;
+                query[i].stopTX = query[i + 1].stopTX;
+              }
+            }
 …
         int maxPulse = argv[3] + (argv[4] << 7);
+        if (IS_PIN_SERVO(pin)) {
+          if (servos[PIN_TO_SERVO(pin)].attached())
+            servos[PIN_TO_SERVO(pin)].detach();
+          servos[PIN_TO_SERVO(pin)].attach(PIN_TO_DIGITAL(pin), minPulse, maxPulse);
+          setPinModeCallback(pin, SERVO);
+        if (IS_PIN_DIGITAL(pin)) {
+          if (servoPinMap[pin] < MAX_SERVOS && servos[servoPinMap[pin]].attached()) {
+            detachServo(pin);
+          }
+          attachServo(pin, minPulse, maxPulse);
+          setPinModeCallback(pin, PIN_MODE_SERVO);
+        }
+      }
 …
           Firmata.write((byte)INPUT);
           Firmata.write(1);
+          Firmata.write((byte)PIN_MODE_PULLUP);
+          Firmata.write(1);
           Firmata.write((byte)OUTPUT);
           Firmata.write(1);
+        }
         if (IS_PIN_ANALOG(pin)) {
           Firmata.write(ANALOG);
           Firmata.write(10);
+          Firmata.write(PIN_MODE_ANALOG);
+          Firmata.write(10); // 10 = 10-bit resolution
+        }
         if (IS_PIN_PWM(pin)) {
           Firmata.write(PWM);
           Firmata.write(8);
+        }
         if (IS_PIN_SERVO(pin)) {
           Firmata.write(SERVO);
+          Firmata.write(PIN_MODE_PWM);
+          Firmata.write(8); // 8 = 8-bit resolution
+        }
+        if (IS_PIN_DIGITAL(pin)) {
+          Firmata.write(PIN_MODE_SERVO);
           Firmata.write(14);
+        }
         if (IS_PIN_I2C(pin)) {
+          Firmata.write(I2C);
+          Firmata.write(1);  // to do: determine appropriate value
+        }
+          Firmata.write(PIN_MODE_I2C);
+          Firmata.write(1);  // TODO: could assign a number to map to SCL or SDA
+        }
+#ifdef FIRMATA_SERIAL_FEATURE
+        serialFeature.handleCapability(pin);
+#endif
         Firmata.write(127);
+      }
 …
         Firmata.write(pin);
         if (pin < TOTAL_PINS) {
           Firmata.write((byte)pinConfig[pin]);
           Firmata.write((byte)pinState[pin] & 0x7F);
           if (pinState[pin] & 0xFF80) Firmata.write((byte)(pinState[pin] >> 7) & 0x7F);
           if (pinState[pin] & 0xC000) Firmata.write((byte)(pinState[pin] >> 14) & 0x7F);
+          Firmata.write(Firmata.getPinMode(pin));
+          Firmata.write((byte)Firmata.getPinState(pin) & 0x7F);
+          if (Firmata.getPinState(pin) & 0xFF80) Firmata.write((byte)(Firmata.getPinState(pin) >> 7) & 0x7F);
+          if (Firmata.getPinState(pin) & 0xC000) Firmata.write((byte)(Firmata.getPinState(pin) >> 14) & 0x7F);
+        }
         Firmata.write(END_SYSEX);
 …
       Firmata.write(END_SYSEX);
       break;
+  }
+}
+void enableI2CPins()
+{
+  byte i;
+  // is there a faster way to do this? would probaby require importing
+  // Arduino.h to get SCL and SDA pins
+  for (i = 0; i < TOTAL_PINS; i++) {
+    if (IS_PIN_I2C(i)) {
+      // mark pins as i2c so they are ignore in non i2c data requests
+      setPinModeCallback(i, I2C);
+    }
+  }
+  isI2CEnabled = true;
+  // is there enough time before the first I2C request to call this here?
+  Wire.begin();
+}
+/* disable the i2c pins so they can be used for other functions */
+void disableI2CPins() {
+  isI2CEnabled = false;
+  // disable read continuous mode for all devices
+  queryIndex = -1;
+  // uncomment the following if or when the end() method is added to Wire library
+  // Wire.end();
+}
+    case SERIAL_MESSAGE:
+#ifdef FIRMATA_SERIAL_FEATURE
+      serialFeature.handleSysex(command, argc, argv);
+#endif
+      break;
+  }
+}
 /*==============================================================================
 …
 void systemResetCallback()
+{
+  isResetting = true;
   // initialize a defalt state
   // TODO: option to load config from EEPROM instead of default
+#ifdef FIRMATA_SERIAL_FEATURE
+  serialFeature.reset();
+#endif
   if (isI2CEnabled) {
     disableI2CPins();
+  }
   for (byte i = 0; i < TOTAL_PORTS; i++) {
     reportPINs[i] = false;      // by default, reporting off
     portConfigInputs[i] = 0;    // until activated
+    reportPINs[i] = false;    // by default, reporting off
+    portConfigInputs[i] = 0;  // until activated
     previousPINs[i] = 0;
+  }
+  // pins with analog capability default to analog input
+  // otherwise, pins default to digital output
   for (byte i = 0; i < TOTAL_PINS; i++) {
+    // pins with analog capability default to analog input
+    // otherwise, pins default to digital output
     if (IS_PIN_ANALOG(i)) {
       // turns off pullup, configures everything
       setPinModeCallback(i, ANALOG);
     } else {
+      setPinModeCallback(i, PIN_MODE_ANALOG);
+    } else if (IS_PIN_DIGITAL(i)) {
       // sets the output to 0, configures portConfigInputs
       setPinModeCallback(i, OUTPUT);
+    }
+    servoPinMap[i] = 255;
+  }
   // by default, do not report any analog inputs
   analogInputsToReport = 0;
+  detachedServoCount = 0;
+  servoCount = 0;
   /* send digital inputs to set the initial state on the host computer,
 …
+  }
   */
+  isResetting = false;
+}
 void setup()
+{
   Firmata.setFirmwareVersion(FIRMATA_MAJOR_VERSION, FIRMATA_MINOR_VERSION);
+  Firmata.setFirmwareVersion(FIRMATA_FIRMWARE_MAJOR_VERSION, FIRMATA_FIRMWARE_MINOR_VERSION);
   Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
 …
   Firmata.attach(REPORT_DIGITAL, reportDigitalCallback);
   Firmata.attach(SET_PIN_MODE, setPinModeCallback);
+  Firmata.attach(SET_DIGITAL_PIN_VALUE, setPinValueCallback);
   Firmata.attach(START_SYSEX, sysexCallback);
   Firmata.attach(SYSTEM_RESET, systemResetCallback);
+  // to use a port other than Serial, such as Serial1 on an Arduino Leonardo or Mega,
+  // Call begin(baud) on the alternate serial port and pass it to Firmata to begin like this:
+  // Serial1.begin(57600);
+  // Firmata.begin(Serial1);
+  // However do not do this if you are using SERIAL_MESSAGE
   Firmata.begin(57600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for ATmega32u4-based boards and Arduino 101
+  }
   systemResetCallback();  // reset to default config
+}
 …
   checkDigitalInputs();
   /* SERIALREAD - processing incoming messagse as soon as possible, while still
+  /* STREAMREAD - processing incoming messagse as soon as possible, while still
    * checking digital inputs.  */
   while (Firmata.available())
     Firmata.processInput();
+  /* SEND FTDI WRITE BUFFER - make sure that the FTDI buffer doesn't go over
+   * 60 bytes. use a timer to sending an event character every 4 ms to
+   * trigger the buffer to dump. */
+  // TODO - ensure that Stream buffer doesn't go over 60 bytes
   currentMillis = millis();
 …
     /* ANALOGREAD - do all analogReads() at the configured sampling interval */
     for (pin = 0; pin < TOTAL_PINS; pin++) {
       if (IS_PIN_ANALOG(pin) && pinConfig[pin] == ANALOG) {
+      if (IS_PIN_ANALOG(pin) && Firmata.getPinMode(pin) == PIN_MODE_ANALOG) {
         analogPin = PIN_TO_ANALOG(pin);
         if (analogInputsToReport & (1 << analogPin)) {
 …
     if (queryIndex > -1) {
       for (byte i = 0; i < queryIndex + 1; i++) {
+        readAndReportData(query[i].addr, query[i].reg, query[i].bytes);
+      }
+    }
+  }
+}
+        readAndReportData(query[i].addr, query[i].reg, query[i].bytes, query[i].stopTX);
+      }
+    }
+  }
+#ifdef FIRMATA_SERIAL_FEATURE
+  serialFeature.update();
+#endif
+}

rtos_arduino/trunk/arduino_lib/libraries/Firmata/keywords.txt

-              r136
+              r224
 #######################################
 Firmata KEYWORD1
 callbackFunction        KEYWORD1
 systemResetCallbackFunction     KEYWORD1
 stringCallbackFunction  KEYWORD1
 sysexCallbackFunction   KEYWORD1
+Firmata                         KEYWORD1        Firmata
+callbackFunction                KEYWORD1        callbackFunction
+systemResetCallbackFunction     KEYWORD1        systemResetCallbackFunction
+stringCallbackFunction          KEYWORD1        stringCallbackFunction
+sysexCallbackFunction           KEYWORD1        sysexCallbackFunction
 #######################################
 …
 #######################################
+begin   KEYWORD2
+begin   KEYWORD2
+printVersion    KEYWORD2
+blinkVersion    KEYWORD2
+printFirmwareVersion    KEYWORD2
+setFirmwareVersion      KEYWORD2
+begin                           KEYWORD2
+printVersion                    KEYWORD2
+blinkVersion                    KEYWORD2
+printFirmwareVersion            KEYWORD2
+setFirmwareVersion              KEYWORD2
 setFirmwareNameAndVersion       KEYWORD2
+available       KEYWORD2
+processInput    KEYWORD2
+sendAnalog      KEYWORD2
+sendDigital     KEYWORD2
+sendDigitalPortPair     KEYWORD2
+sendDigitalPort KEYWORD2
+sendString      KEYWORD2
+sendString      KEYWORD2
+sendSysex       KEYWORD2
+attach  KEYWORD2
+detach  KEYWORD2
+flush   KEYWORD2
+available                       KEYWORD2
+processInput                    KEYWORD2
+isParsingMessage                KEYWORD2
+parse                           KEYWORD2
+sendAnalog                      KEYWORD2
+sendDigital                     KEYWORD2
+sendDigitalPort                 KEYWORD2
+sendString                      KEYWORD2
+sendSysex                       KEYWORD2
+getPinMode                      KEYWORD2
+setPinMode                      KEYWORD2
+getPinState                     KEYWORD2
+setPinState                     KEYWORD2
+attach                          KEYWORD2
+detach                          KEYWORD2
+write                           KEYWORD2
+sendValueAsTwo7bitBytes KEYWORD2
+startSysex                      KEYWORD2
+endSysex                        KEYWORD2
+writePort                       KEYWORD2
+readPort                        KEYWORD2
+disableBlinkVersion             KEYWORD2
 …
 #######################################
+MAX_DATA_BYTES  LITERAL1
+FIRMATA_MAJOR_VERSION   LITERAL1
+FIRMATA_MINOR_VERSION   LITERAL1
+FIRMATA_BUGFIX_VERSION  LITERAL1
+DIGITAL_MESSAGE LITERAL1
+ANALOG_MESSAGE  LITERAL1
+REPORT_ANALOG   LITERAL1
+REPORT_DIGITAL  LITERAL1
+REPORT_VERSION  LITERAL1
+SET_PIN_MODE    LITERAL1
+SYSTEM_RESET    LITERAL1
+MAX_DATA_BYTES          LITERAL1
+START_SYSEX     LITERAL1
+END_SYSEX       LITERAL1
+DIGITAL_MESSAGE         LITERAL1
+ANALOG_MESSAGE          LITERAL1
+REPORT_ANALOG           LITERAL1
+REPORT_DIGITAL          LITERAL1
+REPORT_VERSION          LITERAL1
+SET_PIN_MODE            LITERAL1
+SET_DIGITAL_PIN_VALUE   LITERAL1
+SYSTEM_RESET            LITERAL1
+START_SYSEX             LITERAL1
+END_SYSEX               LITERAL1
+REPORT_FIRMWARE         LITERAL1
+STRING_DATA             LITERAL1
+PWM     LITERAL1
+PIN_MODE_ANALOG         LITERAL1
+PIN_MODE_PWM            LITERAL1
+PIN_MODE_SERVO          LITERAL1
+PIN_MODE_SHIFT          LITERAL1
+PIN_MODE_I2C            LITERAL1
+PIN_MODE_ONEWIRE        LITERAL1
+PIN_MODE_STEPPER        LITERAL1
+PIN_MODE_ENCODER        LITERAL1
+PIN_MODE_SERIAL         LITERAL1
+PIN_MODE_PULLUP         LITERAL1
+PIN_MODE_IGNORE         LITERAL1
+TOTAL_PINS              LITERAL1
 TOTAL_ANALOG_PINS       LITERAL1
 TOTAL_DIGITAL_PINS      LITERAL1
+TOTAL_PORTS                     LITERAL1
+ANALOG_PORT                     LITERAL1
+TOTAL_PIN_MODES         LITERAL1
+TOTAL_PORTS             LITERAL1
+ANALOG_PORT             LITERAL1
+MAX_SERVOS              LITERAL1

rtos_arduino/trunk/arduino_lib/libraries/Firmata/library.properties

-              r136
+              r224
 name=Firmata
 version=2.3.6
+version=2.5.2
 author=Firmata Developers
 maintainer=Firmata Developers <firmata-devel@lists.sourceforge.net>
+maintainer=https://github.com/firmata/arduino
 sentence=Enables the communication with computer apps using a standard serial protocol. For all Arduino boards.
 paragraph=The Firmata library implements the Firmata protocol for communicating with software on the host computer. This allows you to write custom firmware without having to create your own protocol and objects for the programming environment that you are using.
 category=Device Control
 url=http://firmata.org
+url=https://github.com/firmata/arduino
 architectures=*

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/examples/LuckyTest/LuckyTest.ino

r175	r224
79	79
80	80	//read magnetometer sensor
	81	lucky.magnetometer().read();
81	82	Serial.print("Mx: ");
82	83	Serial.print(lucky.magnetometer().x());

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/library.properties

r175	r224
1	1	name=Lucky Shield
2		version=1.0.2
	2	version=1.0.3
3	3	author=Arduino srl
4	4	maintainer=Arduino srl <swdev@arduino.org>

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/src/Lucky.h

-              r175
+              r224
 #include "Wire.h"
+#ifdef __SAM3X8E__
+#define Wire Wire1
+#endif
 class Lucky
+{

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/src/lib/Adafruit_SSD1306.cpp

-              r175
+              r224
 #include "Adafruit_SSD1306.h"
+#ifdef __SAM3X8E__
+#define Wire Wire1
+#endif
 // the memory buffer for the LCD

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/src/lib/Adafruit_SSD1306.h

-              r175
+              r224
   int8_t _i2caddr, _vccstate, sid, sclk, dc, rst, cs;
   boolean hwSPI;
   PortReg *mosiport, *clkport, *csport, *dcport;
   PortMask mosipinmask, clkpinmask, cspinmask, dcpinmask;
+  //boolean hwSPI;
+  //PortReg *mosiport, *clkport, *csport, *dcport;
+  //PortMask mosipinmask, clkpinmask, cspinmask, dcpinmask;
   inline void drawFastVLineInternal(int16_t x, int16_t y, int16_t h, uint16_t color) __attribute__((always_inline));

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/src/lib/BME280.cpp

-              r175
+              r224
 #include "BME280.h"
+#ifdef __SAM3X8E__
+#define Wire Wire1
+#endif
 /***************************************************************************

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/src/lib/CAT9555.cpp

-              r175
+              r224
 #include "CAT9555.h"
 #include <Wire.h>
+#ifdef __SAM3X8E__
+#define Wire Wire1
+#endif
 // CONSTRUCTUR

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/src/lib/MAG3110.cpp

-              r175
+              r224
 //Constructor
+MAG3110::MAG3110()
+{
+}
+// MAG3110::MAG3110()
+// {
+// }
 // Configure magnetometer
 void MAG3110::begin(void) {
+  //CTRL_REG1
+  //DR2|DR1|DR0|OS1|OS0|FastRead|Trigger|ActiveMode|
+  // 0 | 1 | 1 | 1 | 1 |    0   |   0   |    1     |=dec121
   Wire.beginTransmission(MAG_ADDR);// transmit to device 0x0E
   Wire.write(0x10);                // cntrl register1
   Wire.write(0x79); // Active Mode, 1.25 Hz datarate, 8x oversampling
   Wire.endTransmission();          // stop transmitting
+  Wire.write(0x11);              // cntrl register2
+  Wire.write(0x80);              // send 0x80, enable auto resets
+  Wire.endTransmission();       // stop transmitting
   delay(15);
-  //CTRL_REG2:
-  //AutoMagRst|---|Raw|Mag_Rst|---|---|---|---|
-  //    1     | 0 | 0 |   0   | 0 | 0 | 0 | 0 |
   Wire.beginTransmission(MAG_ADDR);// transmit to device 0x0E
   Wire.write(0x11);                // cntrl register2
   Wire.write(0x80);        // Auto resets before each measurement
   Wire.endTransmission();          // stop transmitting
+  Wire.write(0x10);              // cntrl register1
+  Wire.write(1);                 // send 0x01, active mode
+  Wire.endTransmission();       // stop transmitting
+}
+void MAG3110::read()
+{
+  mag_x =read16Data(0x01,0x02);
+  mag_y =read16Data(0x03,0x04);
+  mag_z =read16Data(0x05,0x06);
+}
+// read X value
+// read X value
+int MAG3110::readx(void)
+int MAG3110::read16Data(byte MSB, byte LSB)
+{
   int xl, xh;  //define the MSB and LSB
   Wire.beginTransmission(MAG_ADDR); // transmit to device 0x0E
   Wire.write(0x01);              // x MSB reg
+  Wire.write(MSB);              // x MSB reg
   Wire.endTransmission();       // stop transmitting
 …
   Wire.beginTransmission(MAG_ADDR); // transmit to device 0x0E
   Wire.write(0x02);              // x LSB reg
+  Wire.write(LSB);              // x LSB reg
   Wire.endTransmission();       // stop transmitting
 …
+  }
+  int xout = (xl|(xh << 8)); //concatenate the MSB and LSB
+  return xout;
+  int out = (xl|(xh << 8)); //concatenate the MSB and LSB
+  if (out & 0b1000000000000000){
+     //float yout1 = ((~yout & 0b0111111111111111)+ 1)*(-1) ;
+    return float ((~out & 0b0111111111111111)+ 1)*(-1) ;
+  }
+  return float (out);
+}
-//read Y value
-int MAG3110::ready(void)
+{
-  int yl, yh;  //define the MSB and LSB
-  Wire.beginTransmission(MAG_ADDR); // transmit to device 0x0E
-  Wire.write(0x03);              // y MSB reg
-  Wire.endTransmission();       // stop transmitting
-  delayMicroseconds(2); //needs at least 1.3us free time between start and stop
-  Wire.requestFrom(MAG_ADDR, 1); // request 1 byte
-  while(Wire.available())    // slave may send less than requested
+  {
-    yh = Wire.read(); // receive the byte
+  }
-  delayMicroseconds(2); //needs at least 1.3us free time between start and stop
-  Wire.beginTransmission(MAG_ADDR); // transmit to device 0x0E
-  Wire.write(0x04);              // y LSB reg
-  Wire.endTransmission();       // stop transmitting
-  delayMicroseconds(2); //needs at least 1.3us free time between start and stop
-  Wire.requestFrom(MAG_ADDR, 1); // request 1 byte
-  while(Wire.available())    // slave may send less than requested
+  {
-    yl = Wire.read(); // receive the byte
+  }
-  int yout = (yl|(yh << 8)); //concatenate the MSB and LSB
-  return yout;
+}
-// read Z value
-int MAG3110::readz(void)
+{
-  int zl, zh;  //define the MSB and LSB
-  Wire.beginTransmission(MAG_ADDR); // transmit to device 0x0E
-  Wire.write(0x05);              // z MSB reg
-  Wire.endTransmission();       // stop transmitting
-  delayMicroseconds(2); //needs at least 1.3us free time between start and stop
-  Wire.requestFrom(MAG_ADDR, 1); // request 1 byte
-  while(Wire.available())    // slave may send less than requested
+  {
-    zh = Wire.read(); // receive the byte
+  }
-  delayMicroseconds(2); //needs at least 1.3us free time between start and stop
-  Wire.beginTransmission(MAG_ADDR); // transmit to device 0x0E
-  Wire.write(0x06);              // z LSB reg
-  Wire.endTransmission();       // stop transmitting
-  delayMicroseconds(2); //needs at least 1.3us free time between start and stop
-  Wire.requestFrom(MAG_ADDR, 1); // request 1 byte
-  while(Wire.available())    // slave may send less than requested
+  {
-    zl = Wire.read(); // receive the byte
+  }
-  int zout = (zl|(zh << 8)); //concatenate the MSB and LSB
-  return zout;
+}
 MAG3110 mag3110;

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/src/lib/MAG3110.h

-              r175
+              r224
+{
   public:
+    MAG3110();
+    //constructor
+    //MAG3110();
+    //public methods
     void begin();
+    int readx();
+    int ready();
+    int readz();
+        int x(){return readx();};
+        int y(){return ready();};
+        int z(){return readz();};
+    void read();
+    int x(){return mag_x;};
+    int y(){return mag_y;};
+    int z(){return mag_z;};
   private:
+    //class-only methods:
+    int read16Data(byte MSB, byte LSB);
+    //global variables
+    int mag_x;
+    int mag_y;
+    int mag_z;
 };

rtos_arduino/trunk/arduino_lib/libraries/LuckyShield/src/lib/MMA8491Q.cpp

-              r175
+              r224
 #include "MMA8491Q.h"
 #include <Wire.h>
+#ifdef __SAM3X8E__
+#define Wire Wire1
+#endif
 // CONSTRUCTUR

rtos_arduino/trunk/arduino_lib/libraries/Servo/src/Servo.h

-              r136
+              r224
 #elif defined(ARDUINO_ARCH_SAMD)
         //#include "samd/ServoTimersSamd.h"
+        #define MIN_PULSE_WIDTH_SAMD 500
+        #define MAX_PULSE_WIDTH_SAMD 2100
+        #define MIN_PULSE_WIDTH_SAMD_TCC 405
+        #define MAX_PULSE_WIDTH_SAMD_TCC 2300
+        #define MIN_PULSE_WIDTH_SAMD_TC 1700
+        #define MAX_PULSE_WIDTH_SAMD_TC 9200
 #else
         #error "This library only supports boards with an AVR,SAM or SAMD processor."

rtos_arduino/trunk/arduino_lib/libraries/Servo/src/samd/Servo.cpp

-              r136
+              r224
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */
+//Edited by Arduino Srl development team.
 #if defined(ARDUINO_ARCH_SAMD)
 …
 #include <Servo.h>
 static servo_t servos[MAX_SERVOS];                          // static array of servo structures
 uint8_t ServoCount = 0;                                     // the total number of attached servos
+uint8_t isTC = 0 ;
+Tc* TCx ;
 Tcc* TCCx;
 uint8_t Channelx = 0;
 …
 // convenience macros
+#define SERVO_MIN() (MIN_PULSE_WIDTH_SAMD)  // minimum value in uS for this servo
+#define SERVO_MAX() (MAX_PULSE_WIDTH_SAMD)  // maximum value in uS for this servo
+#define SERVO_MIN_TCC() (MIN_PULSE_WIDTH_SAMD_TCC)  // minimum value in uS for this servo if TCC timer is used
+#define SERVO_MAX_TCC() (MAX_PULSE_WIDTH_SAMD_TCC)  // maximum value in uS for this servo if TCC timer is used
+#define SERVO_MIN_TC() (MIN_PULSE_WIDTH_SAMD_TC)  // minimum value in uS for this servo if TC timer is used
+#define SERVO_MAX_TC() (MAX_PULSE_WIDTH_SAMD_TC)  // maximum value in uS for this servo if TC timer is used
 /************ static functions common to all instances ***********************/
 …
   if (ServoCount < MAX_SERVOS) {
     this->servoIndex = ServoCount++;                    // assign a servo index to this instance
   } else {                                                  //su questo costruttore forse si deve tornare
     this->servoIndex = INVALID_SERVO;  // too many servos
+  } else {
+    this->servoIndex = INVALID_SERVO;                                   // too many servos
+  }
+}
 …
 uint8_t Servo::attach(int pin)
+{
+  return this->attach(pin, MIN_PULSE_WIDTH_SAMD, MAX_PULSE_WIDTH_SAMD);
+  if((servos[this->servoIndex].Pin.nbr==4) | (servos[this->servoIndex].Pin.nbr==5) | (servos[this->servoIndex].Pin.nbr==10) | (servos[this->servoIndex].Pin.nbr==12) ){
+        return this->attach(pin, SERVO_MIN_TC(), SERVO_MAX_TC());
+  }
+  else{
+        return this->attach(pin, SERVO_MIN_TCC(), SERVO_MAX_TCC());
+  }
+}
 …
     pinMode(pin, OUTPUT);                                   // set servo pin to output
     servos[this->servoIndex].Pin.nbr = pin;
+    if(min > MIN_PULSE_WIDTH_SAMD) min = MIN_PULSE_WIDTH_SAMD;
+        if (max > MAX_PULSE_WIDTH_SAMD) max = MAX_PULSE_WIDTH_SAMD;
+        int servo_min, servo_max;
+        if(pin==4 | pin==5 | pin==10 | pin==12){
+                servo_min=SERVO_MIN_TC();
+                servo_max=SERVO_MAX_TC();
+        }
+        else{
+                servo_min=SERVO_MIN_TCC();
+                servo_max=SERVO_MAX_TCC();
+        }
+    if(min > servo_min) min = servo_min;
+        if (max > servo_max) max = servo_max;
         this->min  = min;
     this->max  = max;
 …
                         TCCx=TCC0;
                         Channelx=0;
+                        isTC=0;
+                }
                 break;
 …
                         TCCx=TCC0;
                         Channelx=1;
+                }
+                break;
+                        isTC=0;
+                }
+                break;
+                        case 4:
+                {
+                        pinPeripheral(pin, g_APinDescription[pin].ulPinType);
+                        TCx=TC3;
+                        Channelx=0;
+                        isTC=1;
+                }
+                break;
+                case 5:
+                {
+                        pinPeripheral(pin, g_APinDescription[pin].ulPinType);
+                        TCx=TC3;
+                        Channelx=1;
+                        isTC=1;
+                }
+                break;
                 case 6:
+                {
 …
                         TCCx=TCC0;
                         Channelx=2;
+                        isTC=0;
+                }
                 break;
 …
                         TCCx=TCC0;
                         Channelx=3;
+                        isTC=0;
+                }
                 break;
 …
                         TCCx=TCC1;
                         Channelx=0;
+                        isTC=0;
+                }
                 break;
 …
                         TCCx=TCC1;
                         Channelx=1;
+                        isTC=0;
+                }
+                break;
+                case 10:
+                {
+                        pinPeripheral(pin, g_APinDescription[pin].ulPinType);
+                        TCx=TC3;
+                        Channelx=0;
+                        isTC=1;
+                }
                 break;
 …
                         TCCx=TCC2;
                         Channelx=0;
+                        isTC=0;
+                }
+                break;
+                case 12:
+                {
+                        pinPeripheral(pin, g_APinDescription[pin].ulPinType);
+                        TCx=TC3;
+                        Channelx=1;
+                        isTC=1;
+                }
                 break;
 …
                         TCCx=TCC2;
                         Channelx=1;
+                        isTC=0;
+                }
                 break;
 …
         if ((TCCx==TCC0) | (TCCx==TCC1)) GCLK->CLKCTRL.reg = (uint16_t) (GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK3 | GCLK_CLKCTRL_ID( GCM_TCC0_TCC1 )) ;
         else if(TCCx==TCC2) GCLK->CLKCTRL.reg = (uint16_t) (GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK3 | GCLK_CLKCTRL_ID( GCM_TCC2_TC3 )) ;
+        else if((TCCx==TCC2) | (TCx==TC3 ))GCLK->CLKCTRL.reg = (uint16_t) (GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK3 | GCLK_CLKCTRL_ID( GCM_TCC2_TC3 )) ;
         else;
+        if(servos[this->servoIndex].Pin.isActive == false)
+        {
+                TCCx->CTRLA.reg &=~(TCC_CTRLA_ENABLE);        //disable TCC module
+        if(servos[this->servoIndex].Pin.isActive == false){
+        // Set PORT
+    if ( isTC )
+    {
+      // -- Configure TC
+      //DISABLE TCx
+      TCx->COUNT16.CTRLA.reg &=~(TC_CTRLA_ENABLE);
+      //Set Timer counter Mode to 16 bits
+          TCx->COUNT16.CTRLA.reg |= TC_CTRLA_MODE_COUNT16;
+          //Set Prescaler to divide by 2
+          TCx->COUNT16.CTRLA.reg |= TC_CTRLA_PRESCALER_DIV2;
+      //Set TCx as normal PWM
+      TCx->COUNT16.CTRLA.reg |= TC_CTRLA_WAVEGEN_NPWM;
+          //default value for servo position
+      TCx->COUNT16.CC[Channelx].reg = 1500;
+          //ENABLE TCx
+      TCx->COUNT16.CTRLA.reg |= TC_CTRLA_ENABLE;
+          servos[this->servoIndex].Pin.isActive = true;
+    }
+    else
+    {
+      // -- Configure TCC
+         TCCx->CTRLA.reg &=~(TCC_CTRLA_ENABLE);        //disable TCC module
                 TCCx->CTRLA.reg |=TCC_CTRLA_PRESCALER_DIV8;   //setting prescaler to divide by 8
                 TCCx->WAVE.reg |= TCC_WAVE_WAVEGEN_NPWM;      //Set TCCx as normal PWM
 …
                 TCCx->PER.reg=20000;                          // setting servo frequency (50 hz)
                 TCCx->CTRLA.reg |= TCC_CTRLA_ENABLE ;         //ENABLE TCCx
                 servos[this->servoIndex].Pin.isActive = true;
+        }
+    //servos[this->servoIndex].Pin.isActive = true;  // this must be set after the check for isTimerActive
+                servos[this->servoIndex].Pin.isActive = true;
+    }
+        }
+  }
   return this->servoIndex;
 …
   else if((servos[this->servoIndex].Pin.nbr == 8) | (servos[this->servoIndex].Pin.nbr == 9)) TCC1->CTRLA.reg &=~(TCC_CTRLA_ENABLE);
   else if ((servos[this->servoIndex].Pin.nbr == 11) | (servos[this->servoIndex].Pin.nbr == 13)) TCC2->CTRLA.reg &=~(TCC_CTRLA_ENABLE);
+  else if ((servos[this->servoIndex].Pin.nbr == 4 ) | (servos[this->servoIndex].Pin.nbr == 5 ) | (servos[this->servoIndex].Pin.nbr == 10 ) | (servos[this->servoIndex].Pin.nbr == 12 ))TC3->COUNT16.CTRLA.reg &=~(TC_CTRLA_ENABLE);
+}
 void Servo::write(int value)
+{
+  // treat values less than 544 as angles in degrees (valid values in microseconds are handled as microseconds)
+  if (value < MIN_PULSE_WIDTH)
+  {
+    if (value < 0)
+      value = 0;
+    else if (value > 180)
+      value = 180;
+    value = map(value, 0, 180, SERVO_MIN(), SERVO_MAX());
+  }
+{
+  //select the right values for servo motor
+  int servo_min;
+  int servo_max;
+  if((servos[this->servoIndex].Pin.nbr==4) | (servos[this->servoIndex].Pin.nbr==5) | (servos[this->servoIndex].Pin.nbr==10) | (servos[this->servoIndex].Pin.nbr==12) ){
+        servo_min=SERVO_MIN_TC();
+        servo_max=SERVO_MAX_TC();
+        // treat values less than 1700 as angles in degrees (valid values in microseconds are handled as microseconds)
+        if (value < servo_min)
+        {
+                if (value < 0)
+                        value = 0;
+                else if (value > 180)
+                        value = 180;
+                value = map(value, 0, 180, servo_min, servo_max);
+        }
+  }
+  else{
+        servo_min=SERVO_MIN_TCC();
+        servo_max=SERVO_MAX_TCC();
+        // treat values less than 400 as angles in degrees (valid values in microseconds are handled as microseconds)
+        if (value < servo_min)
+        {
+                if (value < 0)
+                        value = 0;
+                else if (value > 180)
+                        value = 180;
+                value = map(value, 0, 180, servo_min, servo_max);
+        }
+  }
   writeMicroseconds(value);
+}
 …
   if( (channel < MAX_SERVOS) )   // ensure channel is valid
+  {
+    if (value < SERVO_MIN())          // ensure pulse width is valid
+      value = SERVO_MIN();
+    else if (value > SERVO_MAX())
+      value = SERVO_MAX();
+    servos[this->servoIndex].ticks = value;   //da sistemare
+        //select the right values for servo motor
+        int servo_min;
+        int servo_max;
+        if((servos[this->servoIndex].Pin.nbr==4) | (servos[this->servoIndex].Pin.nbr==5) | (servos[this->servoIndex].Pin.nbr==10) | (servos[this->servoIndex].Pin.nbr==12) ){
+                servo_min=SERVO_MIN_TC();
+                servo_max=SERVO_MAX_TC();
+        }
+        else{
+                servo_min=SERVO_MIN_TCC();
+                servo_max=SERVO_MAX_TCC();
+        }
+    if (value < servo_min)          // ensure pulse width is valid
+      value = servo_min;
+    else if (value > servo_max)
+      value = servo_max;
+    servos[this->servoIndex].ticks = value;
         switch(servos[this->servoIndex].Pin.nbr)
+        {
 …
                         break;
+                case 4:
+                        TC3->COUNT16.CC[0].reg = value;
+                        break;
+                case 5:
+                        TC3->COUNT16.CC[1].reg = value;
+                        break;
                 case 6:
                         TCC0->CC[2].reg=value;
 …
                         TCC1->CC[1].reg=value;
                         break;
+                case 10:
+                        TC3->COUNT16.CC[0].reg = value;
+                        break;
                 case 11:
 …
                         break;
+                case 12:
+                        TC3->COUNT16.CC[1].reg = value;
+                        break;
                 case 13:
                         TCC2->CC[1].reg=value;
 …
+        }
     //servos[this->servoIndex].ticks = value;   //da sistemare
+    //servos[this->servoIndex].ticks = value;   //to be fixed
         //servos[channel].ticks = value;
+  }
 …
 int Servo::read() // return the value as degrees
+{
+  return map(readMicroseconds(), SERVO_MIN(), SERVO_MAX(), 0, 180);
+  //select the right values for servo motor
+  int servo_min;
+  int servo_max;
+  if((servos[this->servoIndex].Pin.nbr==4) | (servos[this->servoIndex].Pin.nbr==5) | (servos[this->servoIndex].Pin.nbr==10) | (servos[this->servoIndex].Pin.nbr==12) ){
+        servo_min=SERVO_MIN_TC();
+        servo_max=SERVO_MAX_TC();
+        }
+  else{
+        servo_min=SERVO_MIN_TCC();
+        servo_max=SERVO_MAX_TCC();
+        }
+  return map(readMicroseconds(), servo_min, servo_max, 0, 180);
+}

rtos_arduino/trunk/lib/Makefile.rca

-              r136
+              r224
               wiring.o wiring_digital.o wiring_analog.o wiring_shift.o \
               WInterrupts.o \
               samd21_device.o samd21_host.o \
+              samd21_host.o \
               dtostrf.o \
               itoa.o \
 …
 CDEFS += -Dprintf=iprintf \
          -DF_CPU=48000000L \
          -DARDUINO=10708 \
+         -DARDUINO=10710 \
          -DARDUINO_SAM_ZERO \
          -DARDUINO_ARCH_SAMD \

Context Navigation

Legend:

Download in other formats: