Squashed 'third_party/pico-sdk/lib/tinyusb/' content from commit 868948f67c
Change-Id: I5d33c2566dd597be9d4b1c30d4b3723c5ef4a265
git-subtree-dir: third_party/pico-sdk/lib/tinyusb
git-subtree-split: 868948f67c90fa7c2553cdcd604b52862cf55720
Signed-off-by: Austin Schuh <austin.linux@gmail.com>
diff --git a/examples/device/usbtmc/CMakeLists.txt b/examples/device/usbtmc/CMakeLists.txt
new file mode 100644
index 0000000..c49603c
--- /dev/null
+++ b/examples/device/usbtmc/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.5)
+
+include(${CMAKE_CURRENT_SOURCE_DIR}/../../../hw/bsp/family_support.cmake)
+
+# gets PROJECT name for the example (e.g. <BOARD>-<DIR_NAME>)
+family_get_project_name(PROJECT ${CMAKE_CURRENT_LIST_DIR})
+
+project(${PROJECT})
+
+# Checks this example is valid for the family and initializes the project
+family_initialize_project(${PROJECT} ${CMAKE_CURRENT_LIST_DIR})
+
+add_executable(${PROJECT})
+
+# Example source
+target_sources(${PROJECT} PUBLIC
+ ${CMAKE_CURRENT_SOURCE_DIR}/src/main.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/src/usb_descriptors.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/src/usbtmc_app.c
+ )
+
+# Example include
+target_include_directories(${PROJECT} PUBLIC
+ ${CMAKE_CURRENT_SOURCE_DIR}/src
+ )
+
+# Configure compilation flags and libraries for the example... see the corresponding function
+# in hw/bsp/FAMILY/family.cmake for details.
+family_configure_device_example(${PROJECT})
\ No newline at end of file
diff --git a/examples/device/usbtmc/Makefile b/examples/device/usbtmc/Makefile
new file mode 100644
index 0000000..69b633f
--- /dev/null
+++ b/examples/device/usbtmc/Makefile
@@ -0,0 +1,12 @@
+include ../../../tools/top.mk
+include ../../make.mk
+
+INC += \
+ src \
+ $(TOP)/hw \
+
+# Example source
+EXAMPLE_SOURCE += $(wildcard src/*.c)
+SRC_C += $(addprefix $(CURRENT_PATH)/, $(EXAMPLE_SOURCE))
+
+include ../../rules.mk
diff --git a/examples/device/usbtmc/src/main.c b/examples/device/usbtmc/src/main.c
new file mode 100644
index 0000000..1fce48f
--- /dev/null
+++ b/examples/device/usbtmc/src/main.c
@@ -0,0 +1,143 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "bsp/board.h"
+#include "tusb.h"
+#include "usbtmc_app.h"
+//--------------------------------------------------------------------+
+// MACRO CONSTANT TYPEDEF PROTYPES
+//--------------------------------------------------------------------+
+
+/* Blink pattern
+ * - 250 ms : device not mounted
+ * - 0 ms : device mounted
+ * - 2500 ms : device is suspended
+ */
+enum {
+ BLINK_NOT_MOUNTED = 250,
+ BLINK_MOUNTED = 0,
+ BLINK_SUSPENDED = 2500,
+};
+
+static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
+
+void led_blinking_task(void);
+
+/*------------- MAIN -------------*/
+int main(void)
+{
+ board_init();
+
+ tusb_init();
+
+ while (1)
+ {
+ tud_task(); // tinyusb device task
+ led_blinking_task();
+ usbtmc_app_task_iter();
+ }
+
+ return 0;
+}
+
+//--------------------------------------------------------------------+
+// Device callbacks
+//--------------------------------------------------------------------+
+
+// Invoked when device is mounted
+void tud_mount_cb(void)
+{
+ blink_interval_ms = BLINK_MOUNTED;
+}
+
+// Invoked when device is unmounted
+void tud_umount_cb(void)
+{
+ blink_interval_ms = BLINK_NOT_MOUNTED;
+}
+
+// Invoked when usb bus is suspended
+// remote_wakeup_en : if host allow us to perform remote wakeup
+// Within 7ms, device must draw an average of current less than 2.5 mA from bus
+void tud_suspend_cb(bool remote_wakeup_en)
+{
+ (void) remote_wakeup_en;
+ blink_interval_ms = BLINK_SUSPENDED;
+}
+
+// Invoked when usb bus is resumed
+void tud_resume_cb(void)
+{
+ blink_interval_ms = BLINK_MOUNTED;
+}
+
+//--------------------------------------------------------------------+
+// BLINKING TASK + Indicator pulse
+//--------------------------------------------------------------------+
+
+
+volatile uint8_t doPulse = false;
+// called from USB context
+void led_indicator_pulse(void) {
+ doPulse = true;
+}
+
+void led_blinking_task(void)
+{
+ static uint32_t start_ms = 0;
+ static bool led_state = false;
+ if(blink_interval_ms == BLINK_MOUNTED) // Mounted
+ {
+ if(doPulse)
+ {
+ led_state = true;
+ board_led_write(true);
+ start_ms = board_millis();
+ doPulse = false;
+ }
+ else if (led_state == true)
+ {
+ if ( board_millis() - start_ms < 750) //Spec says blink must be between 500 and 1000 ms.
+ {
+ return; // not enough time
+ }
+ led_state = false;
+ board_led_write(false);
+ }
+ }
+ else
+ {
+ // Blink every interval ms
+ if ( board_millis() - start_ms < blink_interval_ms) return; // not enough time
+ start_ms += blink_interval_ms;
+
+ board_led_write(led_state);
+ led_state = 1 - led_state; // toggle
+ }
+}
diff --git a/examples/device/usbtmc/src/main.h b/examples/device/usbtmc/src/main.h
new file mode 100644
index 0000000..673247e
--- /dev/null
+++ b/examples/device/usbtmc/src/main.h
@@ -0,0 +1,5 @@
+#ifndef MAIN_H
+#define MAIN_H
+void led_indicator_pulse(void);
+
+#endif
diff --git a/examples/device/usbtmc/src/tusb_config.h b/examples/device/usbtmc/src/tusb_config.h
new file mode 100644
index 0000000..a192d0d
--- /dev/null
+++ b/examples/device/usbtmc/src/tusb_config.h
@@ -0,0 +1,89 @@
+/*
+ * tusb_config.h
+ *
+ * Created on: Sep 5, 2019
+ * Author: nconrad
+ */
+
+#ifndef TUSB_CONFIG_H_
+#define TUSB_CONFIG_H_
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+//--------------------------------------------------------------------
+// COMMON CONFIGURATION
+//--------------------------------------------------------------------
+
+// defined by board.mk
+#ifndef CFG_TUSB_MCU
+ #error CFG_TUSB_MCU must be defined
+#endif
+
+// RHPort number used for device can be defined by board.mk, default to port 0
+#ifndef BOARD_DEVICE_RHPORT_NUM
+ #define BOARD_DEVICE_RHPORT_NUM 0
+#endif
+
+// RHPort max operational speed can defined by board.mk
+// Default to Highspeed for MCU with internal HighSpeed PHY (can be port specific), otherwise FullSpeed
+#ifndef BOARD_DEVICE_RHPORT_SPEED
+ #if (CFG_TUSB_MCU == OPT_MCU_LPC18XX || CFG_TUSB_MCU == OPT_MCU_LPC43XX || CFG_TUSB_MCU == OPT_MCU_MIMXRT10XX || \
+ CFG_TUSB_MCU == OPT_MCU_NUC505 || CFG_TUSB_MCU == OPT_MCU_CXD56)
+ #define BOARD_DEVICE_RHPORT_SPEED OPT_MODE_HIGH_SPEED
+ #else
+ #define BOARD_DEVICE_RHPORT_SPEED OPT_MODE_FULL_SPEED
+ #endif
+#endif
+
+// Device mode with rhport and speed defined by board.mk
+#if BOARD_DEVICE_RHPORT_NUM == 0
+ #define CFG_TUSB_RHPORT0_MODE (OPT_MODE_DEVICE | BOARD_DEVICE_RHPORT_SPEED)
+#elif BOARD_DEVICE_RHPORT_NUM == 1
+ #define CFG_TUSB_RHPORT1_MODE (OPT_MODE_DEVICE | BOARD_DEVICE_RHPORT_SPEED)
+#else
+ #error "Incorrect RHPort configuration"
+#endif
+
+#ifndef CFG_TUSB_OS
+#define CFG_TUSB_OS OPT_OS_NONE
+#endif
+
+// CFG_TUSB_DEBUG is defined by compiler in DEBUG build
+// #define CFG_TUSB_DEBUG 0
+
+/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment.
+ * Tinyusb use follows macros to declare transferring memory so that they can be put
+ * into those specific section.
+ * e.g
+ * - CFG_TUSB_MEM SECTION : __attribute__ (( section(".usb_ram") ))
+ * - CFG_TUSB_MEM_ALIGN : __attribute__ ((aligned(4)))
+ */
+#ifndef CFG_TUSB_MEM_SECTION
+#define CFG_TUSB_MEM_SECTION
+#endif
+
+#ifndef CFG_TUSB_MEM_ALIGN
+#define CFG_TUSB_MEM_ALIGN __attribute__ ((aligned(4)))
+#endif
+
+//--------------------------------------------------------------------
+// DEVICE CONFIGURATION
+//--------------------------------------------------------------------
+
+#ifndef CFG_TUD_ENDPOINT0_SIZE
+#define CFG_TUD_ENDPOINT0_SIZE 64
+#endif
+
+//------------- CLASS -------------//
+
+#define CFG_TUD_USBTMC 1
+#define CFG_TUD_USBTMC_ENABLE_INT_EP 1
+#define CFG_TUD_USBTMC_ENABLE_488 1
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* TUSB_CONFIG_H_ */
diff --git a/examples/device/usbtmc/src/usb_descriptors.c b/examples/device/usbtmc/src/usb_descriptors.c
new file mode 100644
index 0000000..4234826
--- /dev/null
+++ b/examples/device/usbtmc/src/usb_descriptors.c
@@ -0,0 +1,194 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "tusb.h"
+#include "class/usbtmc/usbtmc.h"
+#include "class/usbtmc/usbtmc_device.h"
+
+/* A combination of interfaces must have a unique product id, since PC will save device driver after the first plug.
+ * Same VID/PID with different interface e.g MSC (first), then CDC (later) will possibly cause system error on PC.
+ *
+ * Auto ProductID layout's Bitmap:
+ * [MSB] HID | MSC | CDC [LSB]
+ */
+#define _PID_MAP(itf, n) ( (CFG_TUD_##itf) << (n) )
+#define USB_PID (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \
+ _PID_MAP(MIDI, 3) | _PID_MAP(VENDOR, 4) )
+
+//--------------------------------------------------------------------+
+// Device Descriptors
+//--------------------------------------------------------------------+
+tusb_desc_device_t const desc_device =
+{
+ .bLength = sizeof(tusb_desc_device_t),
+ .bDescriptorType = TUSB_DESC_DEVICE,
+ .bcdUSB = 0x0200,
+ .bDeviceClass = 0x00,
+ .bDeviceSubClass = 0x00,
+ .bDeviceProtocol = 0x00,
+
+ .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE,
+
+ .idVendor = 0xCafe,
+ .idProduct = USB_PID,
+ .bcdDevice = 0x0100,
+
+ .iManufacturer = 0x01,
+ .iProduct = 0x02,
+ .iSerialNumber = 0x03,
+
+ .bNumConfigurations = 0x01
+};
+
+// Invoked when received GET DEVICE DESCRIPTOR
+// Application return pointer to descriptor
+uint8_t const * tud_descriptor_device_cb(void)
+{
+ return (uint8_t const *) &desc_device;
+}
+
+//--------------------------------------------------------------------+
+// Configuration Descriptor
+//--------------------------------------------------------------------+
+
+#if defined(CFG_TUD_USBTMC)
+
+# define TUD_USBTMC_DESC_MAIN(_itfnum,_bNumEndpoints) \
+ TUD_USBTMC_IF_DESCRIPTOR(_itfnum, _bNumEndpoints, /*_stridx = */ 4u, TUD_USBTMC_PROTOCOL_USB488), \
+ TUD_USBTMC_BULK_DESCRIPTORS(/* OUT = */0x01, /* IN = */ 0x81, /* packet size = */USBTMCD_MAX_PACKET_SIZE)
+
+#if CFG_TUD_USBTMC_ENABLE_INT_EP
+// USBTMC Interrupt xfer always has length of 2, but we use epMaxSize=8 for
+// compatibility with mcus that only allow 8, 16, 32 or 64 for FS endpoints
+# define TUD_USBTMC_DESC(_itfnum) \
+ TUD_USBTMC_DESC_MAIN(_itfnum, /* _epCount = */ 3), \
+ TUD_USBTMC_INT_DESCRIPTOR(/* INT ep # */ 0x82, /* epMaxSize = */ 8, /* bInterval = */16u )
+# define TUD_USBTMC_DESC_LEN (TUD_USBTMC_IF_DESCRIPTOR_LEN + TUD_USBTMC_BULK_DESCRIPTORS_LEN + TUD_USBTMC_INT_DESCRIPTOR_LEN)
+
+#else
+
+# define TUD_USBTMC_DESC(_itfnum) \
+ TUD_USBTMC_DESC_MAIN(_itfnum, /* _epCount = */ 2u)
+# define TUD_USBTMC_DESC_LEN (TUD_USBTMC_IF_DESCRIPTOR_LEN + TUD_USBTMC_BULK_DESCRIPTORS_LEN)
+
+#endif /* CFG_TUD_USBTMC_ENABLE_INT_EP */
+
+#else
+# define USBTMC_DESC_LEN (0)
+#endif /* CFG_TUD_USBTMC */
+
+enum
+{
+ ITF_NUM_USBTMC,
+ ITF_NUM_TOTAL
+};
+
+
+#define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_USBTMC_DESC_LEN)
+
+#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X || CFG_TUSB_MCU == OPT_MCU_LPC177X_8X || CFG_TUSB_MCU == OPT_MCU_LPC40XX
+ // LPC 17xx and 40xx endpoint type (bulk/interrupt/iso) are fixed by its number
+ // 0 control, 1 In, 2 Bulk, 3 Iso, 4 In etc ...
+ // Note: since CDC EP ( 1 & 2), HID (4) are spot-on, thus we only need to force
+ // endpoint number for MSC to 5
+ #define EPNUM_MSC 0x05
+#else
+ #define EPNUM_MSC 0x03
+#endif
+
+
+uint8_t const desc_configuration[] =
+{
+ // Config number, interface count, string index, total length, attribute, power in mA
+ TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, 0x00, 100),
+
+ TUD_USBTMC_DESC(ITF_NUM_USBTMC),
+};
+
+// Invoked when received GET CONFIGURATION DESCRIPTOR
+// Application return pointer to descriptor
+// Descriptor contents must exist long enough for transfer to complete
+uint8_t const * tud_descriptor_configuration_cb(uint8_t index)
+{
+ (void) index; // for multiple configurations
+ return desc_configuration;
+}
+
+//--------------------------------------------------------------------+
+// String Descriptors
+//--------------------------------------------------------------------+
+
+// array of pointer to string descriptors
+char const* string_desc_arr [] =
+{
+ (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409)
+ "TinyUSB", // 1: Manufacturer
+ "TinyUSB Device", // 2: Product
+ "123456", // 3: Serials, should use chip ID
+ "TinyUSB USBTMC", // 4: USBTMC
+};
+
+static uint16_t _desc_str[32];
+
+// Invoked when received GET STRING DESCRIPTOR request
+// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete
+uint16_t const* tud_descriptor_string_cb(uint8_t index, uint16_t langid)
+{
+ (void) langid;
+
+ size_t chr_count;
+
+ if ( index == 0)
+ {
+ memcpy(&_desc_str[1], string_desc_arr[0], 2);
+ chr_count = 1;
+ }
+ else
+ {
+ // Note: the 0xEE index string is a Microsoft OS 1.0 Descriptors.
+ // https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/microsoft-defined-usb-descriptors
+
+ if ( !(index < sizeof(string_desc_arr)/sizeof(string_desc_arr[0])) ) return NULL;
+
+ const char* str = string_desc_arr[index];
+
+ // Cap at max char
+ chr_count = strlen(str);
+ if ( chr_count > 31 ) {
+ chr_count = 31;
+ }
+
+ // Convert ASCII string into UTF-16
+ for(uint8_t i=0; i<chr_count; i++)
+ {
+ _desc_str[1+i] = str[i];
+ }
+ }
+
+ // first byte is length (including header), second byte is string type
+ _desc_str[0] = (uint16_t)((((uint16_t)TUSB_DESC_STRING) << 8 ) | (2u*chr_count + 2u));
+
+ return _desc_str;
+}
diff --git a/examples/device/usbtmc/src/usbtmc_app.c b/examples/device/usbtmc/src/usbtmc_app.c
new file mode 100644
index 0000000..8f87a6d
--- /dev/null
+++ b/examples/device/usbtmc/src/usbtmc_app.c
@@ -0,0 +1,329 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Nathan Conrad
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include <strings.h>
+#include <stdlib.h> /* atoi */
+#include "tusb.h"
+#include "bsp/board.h"
+#include "main.h"
+
+#if (CFG_TUD_USBTMC_ENABLE_488)
+static usbtmc_response_capabilities_488_t const
+#else
+static usbtmc_response_capabilities_t const
+#endif
+tud_usbtmc_app_capabilities =
+{
+ .USBTMC_status = USBTMC_STATUS_SUCCESS,
+ .bcdUSBTMC = USBTMC_VERSION,
+ .bmIntfcCapabilities =
+ {
+ .listenOnly = 0,
+ .talkOnly = 0,
+ .supportsIndicatorPulse = 1
+ },
+ .bmDevCapabilities = {
+ .canEndBulkInOnTermChar = 0
+ },
+
+#if (CFG_TUD_USBTMC_ENABLE_488)
+ .bcdUSB488 = USBTMC_488_VERSION,
+ .bmIntfcCapabilities488 =
+ {
+ .supportsTrigger = 1,
+ .supportsREN_GTL_LLO = 0,
+ .is488_2 = 1
+ },
+ .bmDevCapabilities488 =
+ {
+ .SCPI = 1,
+ .SR1 = 0,
+ .RL1 = 0,
+ .DT1 =0,
+ }
+#endif
+};
+
+#define IEEE4882_STB_QUESTIONABLE (0x08u)
+#define IEEE4882_STB_MAV (0x10u)
+#define IEEE4882_STB_SER (0x20u)
+#define IEEE4882_STB_SRQ (0x40u)
+
+static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer123456\r\n";
+//static const char idn[] = "TinyUSB,ModelNumber,SerialNumber,FirmwareVer and a bunch of other text to make it longer than a packet, perhaps? lets make it three transfers...\n";
+static volatile uint8_t status;
+
+// 0=not query, 1=queried, 2=delay,set(MAV), 3=delay 4=ready?
+// (to simulate delay)
+static volatile uint16_t queryState = 0;
+static volatile uint32_t queryDelayStart;
+static volatile uint32_t bulkInStarted;
+static volatile uint32_t idnQuery;
+
+static uint32_t resp_delay = 125u; // Adjustable delay, to allow for better testing
+static size_t buffer_len;
+static size_t buffer_tx_ix; // for transmitting using multiple transfers
+static uint8_t buffer[225]; // A few packets long should be enough.
+
+
+static usbtmc_msg_dev_dep_msg_in_header_t rspMsg = {
+ .bmTransferAttributes =
+ {
+ .EOM = 1,
+ .UsingTermChar = 0
+ }
+};
+
+void tud_usbtmc_open_cb(uint8_t interface_id)
+{
+ (void)interface_id;
+ tud_usbtmc_start_bus_read();
+}
+
+#if (CFG_TUD_USBTMC_ENABLE_488)
+usbtmc_response_capabilities_488_t const *
+#else
+usbtmc_response_capabilities_t const *
+#endif
+tud_usbtmc_get_capabilities_cb()
+{
+ return &tud_usbtmc_app_capabilities;
+}
+
+
+bool tud_usbtmc_msg_trigger_cb(usbtmc_msg_generic_t* msg) {
+ (void)msg;
+ // Let trigger set the SRQ
+ status |= IEEE4882_STB_SRQ;
+ return true;
+}
+
+bool tud_usbtmc_msgBulkOut_start_cb(usbtmc_msg_request_dev_dep_out const * msgHeader)
+{
+ (void)msgHeader;
+ buffer_len = 0;
+ if(msgHeader->TransferSize > sizeof(buffer))
+ {
+
+ return false;
+ }
+ return true;
+}
+
+bool tud_usbtmc_msg_data_cb(void *data, size_t len, bool transfer_complete)
+{
+ // If transfer isn't finished, we just ignore it (for now)
+
+ if(len + buffer_len < sizeof(buffer))
+ {
+ memcpy(&(buffer[buffer_len]), data, len);
+ buffer_len += len;
+ }
+ else
+ {
+ return false; // buffer overflow!
+ }
+ queryState = transfer_complete;
+ idnQuery = 0;
+
+ if(transfer_complete && (len >=4) && !strncasecmp("*idn?",data,4))
+ {
+ idnQuery = 1;
+ }
+ if(transfer_complete && !strncasecmp("delay ",data,5))
+ {
+ queryState = 0;
+ int d = atoi((char*)data + 5);
+ if(d > 10000)
+ d = 10000;
+ if(d<0)
+ d=0;
+ resp_delay = (uint32_t)d;
+ }
+ tud_usbtmc_start_bus_read();
+ return true;
+}
+
+bool tud_usbtmc_msgBulkIn_complete_cb()
+{
+ if((buffer_tx_ix == buffer_len) || idnQuery) // done
+ {
+ status &= (uint8_t)~(IEEE4882_STB_MAV); // clear MAV
+ queryState = 0;
+ bulkInStarted = 0;
+ buffer_tx_ix = 0;
+ }
+ tud_usbtmc_start_bus_read();
+
+ return true;
+}
+
+static unsigned int msgReqLen;
+
+bool tud_usbtmc_msgBulkIn_request_cb(usbtmc_msg_request_dev_dep_in const * request)
+{
+ rspMsg.header.MsgID = request->header.MsgID,
+ rspMsg.header.bTag = request->header.bTag,
+ rspMsg.header.bTagInverse = request->header.bTagInverse;
+ msgReqLen = request->TransferSize;
+
+#ifdef xDEBUG
+ uart_tx_str_sync("MSG_IN_DATA: Requested!\r\n");
+#endif
+ if(queryState == 0 || (buffer_tx_ix == 0))
+ {
+ TU_ASSERT(bulkInStarted == 0);
+ bulkInStarted = 1;
+
+ // > If a USBTMC interface receives a Bulk-IN request prior to receiving a USBTMC command message
+ // that expects a response, the device must NAK the request (*not stall*)
+ }
+ else
+ {
+ size_t txlen = tu_min32(buffer_len-buffer_tx_ix,msgReqLen);
+ tud_usbtmc_transmit_dev_msg_data(&buffer[buffer_tx_ix], txlen,
+ (buffer_tx_ix+txlen) == buffer_len, false);
+ buffer_tx_ix += txlen;
+ }
+ // Always return true indicating not to stall the EP.
+ return true;
+}
+
+void usbtmc_app_task_iter(void) {
+ switch(queryState) {
+ case 0:
+ break;
+ case 1:
+ queryDelayStart = board_millis();
+ queryState = 2;
+ break;
+ case 2:
+ if( (board_millis() - queryDelayStart) > resp_delay) {
+ queryDelayStart = board_millis();
+ queryState=3;
+ status |= 0x10u; // MAV
+ status |= 0x40u; // SRQ
+ }
+ break;
+ case 3:
+ if( (board_millis() - queryDelayStart) > resp_delay) {
+ queryState = 4;
+ }
+ break;
+ case 4: // time to transmit;
+ if(bulkInStarted && (buffer_tx_ix == 0)) {
+ if(idnQuery)
+ {
+ tud_usbtmc_transmit_dev_msg_data(idn, tu_min32(sizeof(idn)-1,msgReqLen),true,false);
+ queryState = 0;
+ bulkInStarted = 0;
+ }
+ else
+ {
+ buffer_tx_ix = tu_min32(buffer_len,msgReqLen);
+ tud_usbtmc_transmit_dev_msg_data(buffer, buffer_tx_ix, buffer_tx_ix == buffer_len, false);
+ }
+ // MAV is cleared in the transfer complete callback.
+ }
+ break;
+ default:
+ TU_ASSERT(false,);
+ return;
+ }
+}
+
+bool tud_usbtmc_initiate_clear_cb(uint8_t *tmcResult)
+{
+ *tmcResult = USBTMC_STATUS_SUCCESS;
+ queryState = 0;
+ bulkInStarted = false;
+ status = 0;
+ return true;
+}
+
+bool tud_usbtmc_check_clear_cb(usbtmc_get_clear_status_rsp_t *rsp)
+{
+ queryState = 0;
+ bulkInStarted = false;
+ status = 0;
+ buffer_tx_ix = 0u;
+ buffer_len = 0u;
+ rsp->USBTMC_status = USBTMC_STATUS_SUCCESS;
+ rsp->bmClear.BulkInFifoBytes = 0u;
+ return true;
+}
+bool tud_usbtmc_initiate_abort_bulk_in_cb(uint8_t *tmcResult)
+{
+ bulkInStarted = 0;
+ *tmcResult = USBTMC_STATUS_SUCCESS;
+ return true;
+}
+bool tud_usbtmc_check_abort_bulk_in_cb(usbtmc_check_abort_bulk_rsp_t *rsp)
+{
+ (void)rsp;
+ tud_usbtmc_start_bus_read();
+ return true;
+}
+
+bool tud_usbtmc_initiate_abort_bulk_out_cb(uint8_t *tmcResult)
+{
+ *tmcResult = USBTMC_STATUS_SUCCESS;
+ return true;
+
+}
+bool tud_usbtmc_check_abort_bulk_out_cb(usbtmc_check_abort_bulk_rsp_t *rsp)
+{
+ (void)rsp;
+ tud_usbtmc_start_bus_read();
+ return true;
+}
+
+void tud_usbtmc_bulkIn_clearFeature_cb(void)
+{
+}
+void tud_usbtmc_bulkOut_clearFeature_cb(void)
+{
+ tud_usbtmc_start_bus_read();
+}
+
+// Return status byte, but put the transfer result status code in the rspResult argument.
+uint8_t tud_usbtmc_get_stb_cb(uint8_t *tmcResult)
+{
+ uint8_t old_status = status;
+ status = (uint8_t)(status & ~(IEEE4882_STB_SRQ)); // clear SRQ
+
+ *tmcResult = USBTMC_STATUS_SUCCESS;
+ // Increment status so that we see different results on each read...
+
+ return old_status;
+}
+
+bool tud_usbtmc_indicator_pulse_cb(tusb_control_request_t const * msg, uint8_t *tmcResult)
+{
+ (void)msg;
+ led_indicator_pulse();
+ *tmcResult = USBTMC_STATUS_SUCCESS;
+ return true;
+}
diff --git a/examples/device/usbtmc/src/usbtmc_app.h b/examples/device/usbtmc/src/usbtmc_app.h
new file mode 100644
index 0000000..4de30c2
--- /dev/null
+++ b/examples/device/usbtmc/src/usbtmc_app.h
@@ -0,0 +1,7 @@
+
+#ifndef USBTMC_APP_H
+#define USBTMC_APP_H
+
+void usbtmc_app_task_iter(void);
+
+#endif
diff --git a/examples/device/usbtmc/visaQuery.py b/examples/device/usbtmc/visaQuery.py
new file mode 100644
index 0000000..50a765a
--- /dev/null
+++ b/examples/device/usbtmc/visaQuery.py
@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+
+import visa
+import time
+import sys
+
+
+def test_idn():
+ idn = inst.query("*idn?");
+ assert (idn == "TinyUSB,ModelNumber,SerialNumber,FirmwareVer123456\r\n")
+ assert (inst.is_4882_compliant)
+
+def test_echo(m,n):
+ longstr = "0123456789abcdefghijklmnopqrstuvwxyz" * 50
+ t0 = time.monotonic()
+
+ #Next try echo from 1 to 175 characters (200 is max buffer size on DUT)
+ for i in range(m,n):
+ #print(i)
+ x = longstr[0:i]
+ xt = x + inst.write_termination
+ y = inst.query(x)
+ #print(x)
+ #print (":".join("{:02x}".format(ord(c)) for c in xt))
+ #print (":".join("{:02x}".format(ord(c)) for c in y))
+ assert(xt == y), f"failed i={i}"
+ #inst.read_stb();# Just to make USB logging easier by sending a control query (bad thing is that this made things slow)
+ t = time.monotonic() - t0
+ print(f" elapsed: {t:0.3} sec")
+
+def test_trig():
+ # clear SRQ
+ inst.read_stb()
+ assert (inst.read_stb() == 0)
+ inst.assert_trigger()
+ time.sleep(0.3) # SRQ may have some delay
+ assert (inst.read_stb() & 0x40), "SRQ not set after 0.3 seconds"
+ assert (inst.read_stb() == 0)
+
+
+def test_mav():
+ inst.write("delay 50")
+ inst.read_stb() # clear STB
+ assert (inst.read_stb() == 0)
+ inst.write("123")
+ time.sleep(0.3)
+ assert (inst.read_stb() & 0x10), "MAV not set after 0.5 seconds"
+
+ rsp = inst.read()
+ assert(rsp == "123\r\n")
+
+
+def test_srq():
+ assert (inst.read_stb() == 0)
+ inst.write("123")
+
+ #inst.enable_event(visa.constants.VI_EVENT_SERVICE_REQ, visa.constants.VI_QUEUE)
+ #waitrsp = inst.wait_on_event(visa.constants.VI_EVENT_SERVICE_REQ, 5000)
+ #inst.discard_events(visa.constants.VI_EVENT_SERVICE_REQ, visa.constants.VI_QUEUE)
+ #inst.wait_for_srq()
+ time.sleep(0.3)
+ stb = inst.read_stb()
+ msg = "SRQ not set after 0.5 seconds, was {:02x}".format(stb)
+ assert (stb == 0x50),msg
+
+ assert (inst.read_stb() == 0x10), "SRQ set at second read!"
+
+ rsp = inst.read()
+ assert(rsp == "123\r\n")
+
+def test_read_timeout():
+ inst.timeout = 500
+ # First read with no MAV
+ inst.read_stb()
+ assert (inst.read_stb() == 0)
+ inst.write("delay 500")
+ t0 = time.monotonic()
+ try:
+ rsp = inst.read()
+ assert(false), "Read should have resulted in timeout"
+ except visa.VisaIOError:
+ print(" Got expected exception")
+ t = time.monotonic() - t0
+ assert ((t*1000.0) > (inst.timeout - 300))
+ assert ((t*1000.0) < (inst.timeout + 300))
+ print(f"Delay was {t:0.3}")
+ # Response is still in queue, so send a clear (to be more helpful to the next test)
+ inst.clear()
+ time.sleep(0.3)
+ assert(0 == (inst.read_stb() & 0x10)), "MAV not reset after clear"
+
+def test_abort_in():
+ inst.timeout = 200
+ # First read with no MAV
+ inst.read_stb()
+ assert (inst.read_stb() == 0)
+ inst.write("delay 500")
+ inst.write("xxx")
+ t0 = time.monotonic()
+ try:
+ rsp = inst.read()
+ assert(false), "Read should have resulted in timeout"
+ except visa.VisaIOError:
+ print(" Got expected exception")
+ t = time.monotonic() - t0
+ assert ((t*1000.0) > (inst.timeout - 300))
+ assert ((t*1000.0) < (inst.timeout + 300))
+ print(f" Delay was {t:0.3}")
+ # Response is still in queue, so send a clear (to be more helpful to the next test)
+ inst.timeout = 800
+ y = inst.read()
+ assert(y == "xxx\r\n")
+
+def test_indicate():
+ # perform indicator pulse
+ usb_iface = inst.get_visa_attribute(visa.constants.VI_ATTR_USB_INTFC_NUM)
+ retv = inst.control_in(request_type_bitmap_field=0xA1, request_id=64, request_value=0x0000, index=usb_iface, length=0x0001)
+ assert((retv[1] == visa.constants.StatusCode(0)) and (retv[0] == b'\x01')), f"indicator pulse failed: retv={retv}"
+
+
+def test_multi_read():
+ old_chunk_size = inst.chunk_size
+ longstr = "0123456789abcdefghijklmnopqrstuvwxyz" * 10
+ timeout = 10
+ x = longstr[0:174]
+ inst.chunk_size = 50 # Seems chunk size only applies to read but not write
+ inst.write(x)
+ # I'm not sure how to request just the remaining bit using a max count... so just read it all.
+ y = inst.read()
+ assert (x + "\r\n" == y)
+ #inst.chunk_size = old_chunk_size
+
+def test_stall_ep0():
+ usb_iface = inst.get_visa_attribute(visa.constants.VI_ATTR_USB_INTFC_NUM)
+ inst.read_stb()
+ # This is an invalid request, should create stall.
+ try:
+ retv = inst.control_in(request_type_bitmap_field=0xA1, request_id=60, request_value=0x0000, index=usb_iface, length=0x0001)
+ assert false
+ except visa.VisaIOError:
+ pass
+
+ assert (inst.read_stb() == 0)
+
+
+rm = visa.ResourceManager()
+reslist = rm.list_resources("USB?::?*::INSTR")
+print(reslist)
+
+if (len(reslist) == 0):
+ sys.exit()
+
+inst = rm.open_resource(reslist[0]);
+inst.timeout = 3000
+
+inst.clear()
+
+print("+ IDN")
+test_idn()
+
+print("+test abort in")
+test_abort_in()
+
+
+inst.timeout = 2000
+
+print("+ multi read")
+test_multi_read()
+
+
+print("+ echo delay=0")
+inst.write("delay 0")
+test_echo(1,175)
+
+print("+ echo delay=2")
+inst.write("delay 2")
+test_echo(1,175)
+
+print("+ echo delay=150")
+inst.write("delay 150")
+test_echo(53,76)
+test_echo(165,170)
+
+print("+ Read timeout (no MAV)")
+test_read_timeout()
+
+print("+ Test EP0 stall recovery")
+test_stall_ep0()
+
+print("+ MAV")
+test_mav()
+
+print("+ SRQ")
+test_srq()
+
+print("+ indicate")
+test_indicate()
+
+print("+ TRIG")
+test_trig()
+
+# Untested:
+# abort bulk out
+# LLO, GTL, etc
+# Throughput rate?
+# Transmitting a message using multiple transfers
+
+inst.close()
+print("Test complete")