initial

Author: cristidragomir97

Arduino_USBHIDHost.h

@@ -0,0 +1,2 @@
+#include "src/Mouse.h"
+#include "src/Keyboard.h"

README.md

@@ -0,0 +1,84 @@
+# Arduino_USBHIDHost
+
+
+This library provides support for USB HID devices such as keyboards and mice on the Portenta C33. It should support any device that emulates keyboards (for example, barcode readers). The library automatically detects the insertion of a compatible device on the USB port of the chosen breakout board. You can use `attachConnectionCallback()` to get notified when a compatible device is connected.
+
+The library has two main classes:
+- **Keyboard**: Provides both event callbacks and a standard Arduino [`Stream`](https://www.arduino.cc/reference/en/language/functions/communication/stream/) implementation (e.g., using `read()` and `available()`) for reading keyboard data.
+- **Mouse**: Provides event callbacks for receiving mouse information.
+
+## Examples
+
+- **examples/Mouse** – Demonstrates receiving mouse events via a callback.
+- **examples/Keyboard** – Demonstrates receiving keyboard events via both callbacks and the Stream interface.
+- **examples/MouseAndKeyboard** – Demonstrates simultaneous support for both mouse and keyboard devices.
+
+## Usage
+
+To use this library, simply include the appropriate header(s) in your sketch, attach any callbacks you desire, and then call the device’s `begin()` method in `setup()` and `poll()` in `loop()`. Below are some code snippets illustrating the usage.
+
+### Keyboard
+
+You can use the keyboard class in two ways:
+
+1. **Event Callback:**  
+   Attach a keyboard event callback that will be invoked for every key event (with the ASCII code).  
+   ```cpp
+   void onKeyboardEvent(uint8_t key) {
+     Serial.print("Keyboard event (callback): ");
+     Serial.println((char) key);
+   }
+   
+   void setup(){
+    usbKetboard.begin();
+    usbKeyboard.attachKeyboardEventCallback(onKeyboardEvent);
+   }
+
+   ```
+
+2. **Stream Interface**
+The USBHIDKeyboard class also implements the Arduino Stream interface so you can use standard functions like read() and available()
+```cpp
+void loop() {
+  usbKeyboard.poll();
+  while (usbKeyboard.available() > 0) {
+    char keyChar = usbKeyboard.read();
+    Serial.print(keyChar);
+  }
+}
+```
+
+The connection callback (via attachConnectionCallback()) notifies you when a compatible keyboard is connected.
+
+### Mouse
+Reading Mouse Information
+The mouse class provides a callback that returns a structure containing mouse event data. The structure is defined as follows:
+
+```cpp
+struct HIDMouseEvent {
+  uint8_t buttons;       ///< Bitmask for mouse buttons (e.g., left, right, middle)
+  int16_t xMovement;     ///< Relative movement in the x-direction
+  int16_t yMovement;     ///< Relative movement in the y-direction
+  int16_t wheelMovement; ///< Movement of the mouse wheel
+};
+```
+
+Attach your mouse event callback as shown below:
+
+```cpp
+void onMouseEvent(const HIDMouseEvent &mouseEvent) {
+  Serial.print("Mouse event (callback) - Buttons: ");
+  Serial.print(mouseEvent.buttons);
+  Serial.print(", x: ");
+  Serial.print(mouseEvent.xMovement);
+  Serial.print(", y: ");
+  Serial.print(mouseEvent.yMovement);
+  Serial.print(", wheel: ");
+  Serial.println(mouseEvent.wheelMovement);
+}
+```
+
+```cpp
+usbMouse.attachMouseEventCallback(onMouseEvent);
+```
+

examples/Keyboard/Keyboard.ino

@@ -0,0 +1,31 @@
+#include <Arduino.h>
+#include "Keyboard.h"
+
+USBHIDKeyboard kb;
+
+void onKeyboardConnected() {
+  Serial.println("Keyboard connected (callback).");
+}
+
+void onKeyboardEvent(uint8_t key) {
+  Serial.print("Keyboard event (callback): ");
+  Serial.println((char) key);
+}
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial);
+
+  kb.attachConnectionCallback(onKeyboardConnected);
+  kb.attachKeyboardEventCallback(onKeyboardEvent);
+  kb.begin();
+}
+
+void loop() {
+  kb.poll();
+
+  while (kb.available() > 0) {
+    char c = kb.read();
+    Serial.print(c);
+  }
+}

examples/KeyboardAndMouse/KeyboardAndMouse.ino

@@ -0,0 +1,36 @@
+#include <Arduino.h>
+#include "Mouse.h"
+
+// Create a global mouse instance.
+USBHIDMouse ms;
+
+// User-defined connection callback.
+void onMouseConnected() {
+  Serial.println("Mouse connected (callback).");
+}
+
+// User-defined mouse event callback.
+void onMouseEvent(const HIDMouseEvent &event) {
+  Serial.print("Mouse event (callback) - Buttons: ");
+  Serial.print(event.buttons);
+  Serial.print(", x: ");
+  Serial.print(event.x);
+  Serial.print(", y: ");
+  Serial.print(event.y);
+  Serial.print(", wheel: ");
+  Serial.println(event.wheel);
+}
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial);
+
+  ms.attachConnectionCallback(onMouseConnected);
+  ms.attachMouseEventCallback(onMouseEvent);
+  ms.begin();
+}
+
+void loop() {
+  ms.poll();
+  // Additional mouse processing if needed.
+}

examples/Mouse/Mouse.ino

@@ -0,0 +1,10 @@
+name=Arduino_USBHIDHost
+version=1.0.0
+author=Arduino
+maintainer=Arduino <info@arduino.cc>
+sentence=A library that provides access to using USB HID Devices like mice and keyboards on the Portenta C33 board.
+paragraph=The Arduino Portenta H7 Low Power library provides functionality to enable, get information about, and debug low-power modes on the Portenta H7 board.
+category=Device Control
+url=https://github.com/arduino-libraries/Arduino_USBHIDHost
+architectures=renesas_portanta
+includes=Arduino_USBHIDHost.h

library.properties

@@ -0,0 +1,26 @@
+#include "HIDBase.h"
+
+USBHIDDevice::USBHIDDevice()
+  : isDeviceConnected(false),
+    connectionCallback(nullptr)
+{
+}
+
+USBHIDDevice::~USBHIDDevice() { }
+
+void USBHIDDevice::attachConnectionCallback(HIDConnectionCallback connectionCallback) {
+  this->connectionCallback = connectionCallback;
+}
+
+void USBHIDDevice::handleConnection(HIDDeviceType deviceType) {
+  // Only support keyboard and mouse devices.
+  if (deviceType != HIDDeviceType::KEYBOARD && deviceType != HIDDeviceType::MOUSE) {
+    Serial.println("Error: Connected device is not supported!");
+    while (true) { } // Halt execution.
+  }
+  isDeviceConnected = true;
+  Serial.println("HID device connected successfully.");
+  if (connectionCallback) {
+    connectionCallback();
+  }
+}

src/HIDBase.cpp

@@ -0,0 +1,68 @@
+#ifndef HIDBASE_H
+#define HIDBASE_H
+
+#include <Arduino.h>
+
+/**
+ * @brief Enumeration for HID device types.
+ */
+enum class HIDDeviceType : uint8_t {
+  KEYBOARD,  ///< Keyboard device
+  MOUSE,     ///< Mouse device
+  UNKNOWN    ///< Unknown device
+};
+
+/**
+ * @brief Callback type for a successful HID device connection.
+ *
+ * This callback is raised when an HID device is successfully connected.
+ */
+typedef void (*HIDConnectionCallback)(void);
+
+/**
+ * @brief Base class for USB HID devices.
+ *
+ * Provides common connection callback functionality for all HID devices.
+ */
+class USBHIDDevice {
+public:
+  /**
+   * @brief Construct a new USBHIDDevice object.
+   */
+  USBHIDDevice();
+
+  /**
+   * @brief Destroy the USBHIDDevice object.
+   */
+  virtual ~USBHIDDevice();
+
+  /**
+   * @brief Attach a connection callback.
+   *
+   * @param connectionCallback A callback function to be invoked when the device connects.
+   */
+  void attachConnectionCallback(HIDConnectionCallback connectionCallback);
+
+  /**
+   * @brief Internal handler for connection events.
+   *
+   * Called by the USB host callbacks to indicate a device connection.
+   * If the connected device type is not supported, an error is printed and execution halts.
+   *
+   * @param deviceType The detected HID device type.
+   */
+  void handleConnection(HIDDeviceType deviceType);
+
+  /**
+   * @brief Check whether the device is connected.
+   *
+   * @return true if connected, false otherwise.
+   */
+  bool isConnected() const { return isDeviceConnected; }
+
+protected:
+  bool isDeviceConnected;               ///< Flag indicating if the device is connected.
+  HIDConnectionCallback connectionCallback;  ///< User-provided connection callback.
+};
+
+#endif // HIDBASE_H