Merge pull request #264 from adafruit/add-i2c-tiny-usb

Add i2c-tiny-usb adapter example

Author: hathach

.codespell/ignore-words.txt

@@ -1,3 +1,4 @@
 synopsys
 sie
 inout
+busses

.github/workflows/githubci.yml

@@ -18,8 +18,8 @@ jobs:
     - name: Checkout code
       uses: actions/checkout@v3
 
-    - name: Run codespell
-      uses: codespell-project/actions-codespell@master
+    - name: Run pre-commit
+      uses: pre-commit/action@v3.0.0
 
     - name: Checkout adafruit/ci-arduino
       uses: actions/checkout@v3
@@ -50,7 +50,6 @@ jobs:
            - 'feather_esp32s3'
            # ESP32S2
            - 'feather_esp32s2'
-           - 'metroesp32s2'
            # nRF52
            - 'cpb'
            - 'nrf52840'

.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: 2020 Diego Elio Pettenò
+#
+# SPDX-License-Identifier: Unlicense
+
+repos:
+- repo: https://github.com/codespell-project/codespell
+  rev: v2.2.4
+  hooks:
+  - id: codespell
+    #args: [-w]

examples/Vendor/i2c_tiny_usb_adapter/Adafruit_USBD_I2C.cpp

@@ -0,0 +1,211 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2023 Ha Thach (tinyusb.org) for Adafruit Industries
+ *
+ * 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.
+ */
+
+/*
+ * Reference:
+ * - https://github.com/torvalds/linux/blob/master/drivers/i2c/busses/i2c-tiny-usb.c
+ * - https://github.com/harbaum/I2C-Tiny-USB
+ *
+ * Requirement:
+ * - Install i2c-tools with
+ *    sudo apt install i2c-tools
+ *
+ * How to test example:
+ * - Compile and flash this sketch on your board with an i2c device, it should enumerated as
+ *    ID 1c40:0534 EZPrototypes i2c-tiny-usb interface
+ *
+ * - Run "i2cdetect -l" to find our bus ID e.g
+ *    i2c-8	i2c       	i2c-tiny-usb at bus 003 device 039	I2C adapter
+ *
+ * - Run "i2cdetect -y 8" to scan for on-board device (8 is the above bus ID)
+ *         0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
+      00:                         -- -- -- -- -- -- -- --
+      10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+      20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+      30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+      40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+      50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+      60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+      70: -- -- -- -- -- -- -- 77
+
+   - You can then interact with sensor using following commands:
+     i2cget i2cset i2cdump i2ctransfer or using any driver/tools that work on i2c device.
+ */
+
+#include "Adafruit_USBD_I2C.h"
+
+Adafruit_USBD_I2C::Adafruit_USBD_I2C(TwoWire* wire) {
+  _wire = wire;
+  _buf = NULL;
+  _bufsize = 0; // not used to verify length yet
+  _state = I2C_STATUS_IDLE;
+  _functionality = 0x8eff0001; // check out _functionality_* defines
+  setStringDescriptor("I2C Interface");
+}
+
+uint16_t Adafruit_USBD_I2C::getInterfaceDescriptor(uint8_t itfnum, uint8_t* buf, uint16_t bufsize) {
+  uint8_t desc[] = { TUD_VENDOR_DESCRIPTOR(itfnum, 0, 0x00, 0x80, 64) };
+  uint16_t const len = sizeof(desc);
+  if (buf) {
+    if (bufsize < len) {
+      return 0;
+    }
+    memcpy(buf, desc, len);
+  }
+  return len;
+}
+
+bool Adafruit_USBD_I2C::begin(uint8_t* buffer, size_t bufsize) {
+  _buf = buffer;
+  _bufsize = (uint16_t) bufsize;
+
+  if (!_wire || !_buf || !_bufsize) return false;
+
+  // needed to identify as a device for i2c_tiny_usb (EZPrototypes VID/PID)
+  TinyUSBDevice.setID(0x1c40, 0x0534);
+  if (!TinyUSBDevice.addInterface(*this)) return false;
+
+  _wire->begin();
+  return true;
+}
+
+uint16_t Adafruit_USBD_I2C::i2c_read(uint8_t addr, uint8_t* buf, uint16_t len, bool stop_bit)
+{
+  uint16_t const rd_count = (uint16_t) _wire->requestFrom(addr, len, stop_bit);
+
+  _state = (len && !rd_count) ? I2C_STATUS_NAK : I2C_STATUS_ACK;
+
+  // Serial.printf("I2C Read: addr = 0x%02X, len = %u, rd_count %u bytes, status = %u\r\n", addr, len, rd_count, i2c_state);
+
+  for(uint16_t i = 0; i <rd_count; i++)
+  {
+    buf[i] = (uint8_t) _wire->read();
+  }
+
+  return rd_count;
+}
+
+uint16_t Adafruit_USBD_I2C::i2c_write(uint8_t addr, uint8_t const* buf, uint16_t len, bool stop_bit)
+{
+  _wire->beginTransmission(addr);
+  uint16_t wr_count = (uint16_t) _wire->write(buf, len);
+  uint8_t const sts = _wire->endTransmission(stop_bit);
+
+  _state = (sts == 0) ? I2C_STATUS_ACK : I2C_STATUS_NAK;
+
+  // Serial.printf("I2C Write: addr = 0x%02X, len = %u, wr_count = %u, status = %u\r\n", addr, len, wr_count, i2c_state);
+
+  return wr_count;
+}
+
+bool Adafruit_USBD_I2C::handleControlTransfer(uint8_t rhport, uint8_t stage, tusb_control_request_t const* request) {
+  uint8_t const cmd = request->bRequest;
+
+  if ( stage == CONTROL_STAGE_SETUP )
+  {
+    switch ( cmd )
+    {
+      case CMD_ECHO:
+        // echo
+        return tud_control_xfer(rhport, request, (void*) &request->wValue, sizeof(request->wValue));
+
+      case CMD_GET_FUNC:
+        // capabilities
+        return tud_control_xfer(rhport, request, (void*) &_functionality, sizeof(_functionality));
+
+      case CMD_SET_DELAY:
+        if ( request->wValue == 0 )
+        {
+          _wire->setClock(115200);
+        }
+        else
+        {
+          int baudrate = 1000000 / request->wValue;
+          if ( baudrate > 400000 ) baudrate = 400000;
+          _wire->setClock(baudrate);
+        }
+        return tud_control_status(rhport, request);
+
+      case CMD_GET_STATUS:
+        return tud_control_xfer(rhport, request, (void*) &_state, sizeof(_state));
+
+      case CMD_I2C_IO:
+      case CMD_I2C_IO | CMD_I2C_IO_BEGIN:
+      case CMD_I2C_IO | CMD_I2C_IO_END:
+      case CMD_I2C_IO | CMD_I2C_IO_BEGIN | CMD_I2C_IO_END:
+      {
+        uint8_t const addr = (uint8_t) request->wIndex;
+        // uint16_t const flags = request->wValue;
+        uint16_t const len = tu_min16(request->wLength, _bufsize);
+        bool const stop_bit = (cmd & CMD_I2C_IO_END) ? true : false;
+
+        if (request->bmRequestType_bit.direction == TUSB_DIR_OUT)
+        {
+          if (len == 0)
+          {
+            // zero write: do it here since there will be no data stage for len = 0
+            i2c_write(addr, _buf, len, stop_bit);
+          }
+          return tud_control_xfer(rhport, request, _buf, len);
+        }else
+        {
+          uint16_t const rd_count = i2c_read(addr, _buf, len, stop_bit);
+          return tud_control_xfer(rhport, request, rd_count ? _buf : NULL, rd_count);
+        }
+      }
+      break;
+
+      default: return true;
+    }
+  }
+  else if ( stage == CONTROL_STAGE_DATA )
+  {
+    switch ( cmd )
+    {
+      case CMD_I2C_IO:
+      case CMD_I2C_IO | CMD_I2C_IO_BEGIN:
+      case CMD_I2C_IO | CMD_I2C_IO_END:
+      case CMD_I2C_IO | CMD_I2C_IO_BEGIN | CMD_I2C_IO_END:
+        if (request->bmRequestType_bit.direction == TUSB_DIR_OUT)
+        {
+          uint8_t const addr = (uint8_t) request->wIndex;
+          // uint16_t const flags = request->wValue;
+          uint16_t const len = tu_min16(request->wLength, _bufsize);
+          bool const stop_bit = (cmd & CMD_I2C_IO_END) ? true : false;
+
+          i2c_write(addr, _buf, len, stop_bit);
+        }
+        return true;
+
+      default: return true;
+    }
+  }
+  else
+  {
+    // CONTROL_STAGE_STATUS
+    return true;
+  }
+}
+
+

examples/Vendor/i2c_tiny_usb_adapter/Adafruit_USBD_I2C.h

@@ -0,0 +1,107 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2023 Ha Thach (tinyusb.org) for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef ADAFRUIT_USBD_I2C_H_
+#define ADAFRUIT_USBD_I2C_H_
+
+#include "Adafruit_TinyUSB.h"
+#include "Wire.h"
+
+/* commands from USB, must e.g. match command ids in kernel driver */
+#define CMD_ECHO        0
+#define CMD_GET_FUNC    1
+#define CMD_SET_DELAY   2
+#define CMD_GET_STATUS  3
+
+#define CMD_I2C_IO        4
+#define CMD_I2C_IO_BEGIN  (1<<0) // flag for I2C_IO
+#define CMD_I2C_IO_END    (1<<1) // flag for I2C_IO
+
+/* linux kernel flags */
+#define I2C_M_TEN            0x10  /* we have a ten bit chip address */
+#define I2C_M_RD             0x01
+#define I2C_M_NOSTART        0x4000
+#define I2C_M_REV_DIR_ADDR   0x2000
+#define I2C_M_IGNORE_NAK     0x1000
+#define I2C_M_NO_RD_ACK      0x0800
+
+/* To determine what functionality is present */
+#define I2C_FUNC_I2C                     0x00000001
+#define I2C_FUNC_10BIT_ADDR              0x00000002 /* required for I2C_M_TEN */
+#define I2C_FUNC_PROTOCOL_MANGLING       0x00000004 /* required for I2C_M_IGNORE_NAK etc. */
+#define I2C_FUNC_SMBUS_PEC               0x00000008
+#define I2C_FUNC_NOSTART                 0x00000010 /* required for I2C_M_NOSTART */
+#define I2C_FUNC_SLAVE                   0x00000020
+#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL   0x00008000 /* SMBus 2.0 or later */
+#define I2C_FUNC_SMBUS_QUICK             0x00010000
+#define I2C_FUNC_SMBUS_READ_BYTE         0x00020000
+#define I2C_FUNC_SMBUS_WRITE_BYTE        0x00040000
+#define I2C_FUNC_SMBUS_READ_BYTE_DATA    0x00080000
+#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA   0x00100000
+#define I2C_FUNC_SMBUS_READ_WORD_DATA    0x00200000
+#define I2C_FUNC_SMBUS_WRITE_WORD_DATA   0x00400000
+#define I2C_FUNC_SMBUS_PROC_CALL         0x00800000
+#define I2C_FUNC_SMBUS_READ_BLOCK_DATA   0x01000000 /* required for I2C_M_RECV_LEN */
+#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA  0x02000000
+#define I2C_FUNC_SMBUS_READ_I2C_BLOCK    0x04000000 /* I2C-like block xfer   */
+#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK   0x08000000 /* w/ 1-byte reg. addr. */
+#define I2C_FUNC_SMBUS_HOST_NOTIFY       0x10000000 /* SMBus 2.0 or later */
+
+#define I2C_FUNC_SMBUS_BYTE       (I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE)
+#define I2C_FUNC_SMBUS_BYTE_DATA  (I2C_FUNC_SMBUS_READ_BYTE_DATA | I2C_FUNC_SMBUS_WRITE_BYTE_DATA)
+#define I2C_FUNC_SMBUS_WORD_DATA  (I2C_FUNC_SMBUS_READ_WORD_DATA | I2C_FUNC_SMBUS_WRITE_WORD_DATA)
+#define I2C_FUNC_SMBUS_BLOCK_DATA (I2C_FUNC_SMBUS_READ_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)
+#define I2C_FUNC_SMBUS_I2C_BLOCK  (I2C_FUNC_SMBUS_READ_I2C_BLOCK | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)
+
+#define I2C_FUNC_SMBUS_EMUL    (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA | \
+                                I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
+                                I2C_FUNC_SMBUS_I2C_BLOCK | I2C_FUNC_SMBUS_PEC)
+
+/* if I2C_M_RECV_LEN is also supported */
+#define I2C_FUNC_SMBUS_EMUL_ALL (I2C_FUNC_SMBUS_EMUL | I2C_FUNC_SMBUS_READ_BLOCK_DATA | I2C_FUNC_SMBUS_BLOCK_PROC_CALL)
+
+#define I2C_STATUS_IDLE 0
+#define I2C_STATUS_ACK  1
+#define I2C_STATUS_NAK  2
+
+class Adafruit_USBD_I2C : public Adafruit_USBD_Interface {
+public:
+  Adafruit_USBD_I2C(TwoWire* wire);
+  uint16_t getInterfaceDescriptor(uint8_t itfnum, uint8_t* buf, uint16_t bufsize);
+  bool begin(uint8_t* buffer, size_t bufsize);
+
+  bool handleControlTransfer(uint8_t rhport, uint8_t stage, tusb_control_request_t const* request);
+
+private:
+  TwoWire* _wire;
+  uint8_t _state;
+  uint32_t _functionality;
+  uint8_t* _buf;
+  uint16_t _bufsize;
+
+  uint16_t i2c_write(uint8_t addr, uint8_t const* buf, uint16_t len, bool stop_bit);
+  uint16_t i2c_read(uint8_t addr, uint8_t* buf, uint16_t len, bool stop_bit);
+};
+
+#endif