/* Copyright (C) 2021 Kristian Sloth Lauszus and Dennis Frett. All rights reserved. This software may be distributed and modified under the terms of the GNU General Public License version 2 (GPL2) as published by the Free Software Foundation and appearing in the file GPL2.TXT included in the packaging of this file. Please note that GPL2 Section 2[b] requires that all works based on this software must also be made publicly available under the terms of the GPL2 ("Copyleft"). Contact information ------------------- Kristian Sloth Lauszus Web : https://lauszus.com e-mail : lauszus@gmail.com Dennis Frett GitHub : https://github.com/dennisfrett e-mail : dennis.frett@live.com */ #pragma once #include "hiduniversal.h" #define MINIDSP_VID 0x2752 // MiniDSP #define MINIDSP_PID 0x0011 // MiniDSP 2x4HD /** * Arduino MiniDSP 2x4HD USB Host Driver by Dennis Frett. * * This class implements support for the MiniDSP 2x4HD via USB. * Based on NodeJS implementation by Mathieu Rene: * https://github.com/mrene/node-minidsp and the Python implementation by Mark * Kubiak: https://github.com/markubiak/python3-minidsp. * * It uses the HIDUniversal class for all the USB communication. */ class MiniDSP : public HIDUniversal { public: enum class InputSource : uint8_t { ANALOG = 0x00, TOSLINK = 0x01, USB = 0x02, UNKNOWN = 0x03 }; /** * Constructor for the MiniDSP class. * @param p Pointer to the USB class instance. */ MiniDSP(USB *p) : HIDUniversal(p) { }; /** * Used to check if a MiniDSP 2x4HD is connected. * @return Returns true if it is connected. */ bool connected() { return HIDUniversal::isReady() && HIDUniversal::VID == MINIDSP_VID && HIDUniversal::PID == MINIDSP_PID; }; /** * Used to call your own function when the device is successfully * initialized. * @param funcOnInit Function to call. */ void attachOnInit(void (*funcOnInit)(void)) { pFuncOnInit = funcOnInit; }; /** * Used to call your own function when the volume has changed. * The volume is passed as an unsigned integer that represents twice the * -dB value. Example: 19 represents -9.5dB. * @param funcOnVolumeChange Function to call. */ void attachOnVolumeChange(void (*funcOnVolumeChange)(uint8_t)) { pFuncOnVolumeChange = funcOnVolumeChange; } /** * Used to call your own function when the muted status has changed. * The muted status is passed as a boolean. True means muted, false * means unmuted. * @param funcOnMutedChange Function to call. */ void attachOnMutedChange(void (*funcOnMutedChange)(bool)) { pFuncOnMutedChange = funcOnMutedChange; } /** * Used to call your own function when the input source has changed. * @param funcOnInputSourceChange Function to call. */ void attachOnInputSourceChange(void (*funcOnInputSourceChange)(InputSource)) { pFuncOnInputSourceChange = funcOnInputSourceChange; } /** * Retrieve the current volume of the MiniDSP. * The volume is passed as an unsigned integer that represents twice the * -dB value. Example: 19 represents -9.5dB. * @return Current volume. */ int getVolume() const { return volume; } /** * Retrieve the current volume of the MiniDSP in -dB. * @return Current volume. */ float getVolumeDB() const { return volume / -2.0; } /** * Retrieve the current muted status of the MiniDSP. * @return `true` if the device is muted, `false` otherwise. */ bool isMuted() const { return muted; } /** * Retrieve the current input source of the MiniDSP. * @return Current input source: `ANALOG`, `TOSLINK` or `USB`. */ InputSource getInputSource() const { return inputSource; } protected: /** @name HIDUniversal implementation */ /** * Used to parse USB HID data. * @param hid Pointer to the HID class. * @param is_rpt_id Only used for Hubs. * @param len The length of the incoming data. * @param buf Pointer to the data buffer. */ void ParseHIDData(USBHID *hid, bool is_rpt_id, uint8_t len, uint8_t *buf); /** * Called when a device is successfully initialized. * Use attachOnInit(void (*funcOnInit)(void)) to call your own function. * This is useful for instance if you want to set the LEDs in a specific * way. */ uint8_t OnInitSuccessful(); /**@}*/ /** @name USBDeviceConfig implementation */ /** * Used by the USB core to check what this driver support. * @param vid The device's VID. * @param pid The device's PID. * @return Returns true if the device's VID and PID matches this * driver. */ virtual bool VIDPIDOK(uint16_t vid, uint16_t pid) { return vid == MINIDSP_VID && pid == MINIDSP_PID; }; /**@}*/ private: /** * Calculate checksum for given buffer. * Checksum is given by summing up all bytes in `data` and returning the first byte. * @param data Buffer to calculate checksum for. * @param data_length Length of the buffer. */ uint8_t Checksum(const uint8_t *data, uint8_t data_length) const; /** * Send the "Request status" command to the MiniDSP. The response * includes the current volume and the muted status. */ void RequestStatus() const; void RequestInputSource() const; /** * Send the given MiniDSP command. This function will create a buffer * with the expected header and checksum and send it to the MiniDSP. * Responses will come in throug `ParseHIDData`. * @param command Buffer of the command to send. * @param command_length Length of the buffer. */ void SendCommand(uint8_t *command, uint8_t command_length) const; // Callbacks // Pointer to function called in onInit(). void (*pFuncOnInit)(void) = nullptr; // Pointer to function called when volume changes. void (*pFuncOnVolumeChange)(uint8_t) = nullptr; // Pointer to function called when muted status changes. void (*pFuncOnMutedChange)(bool) = nullptr; // Pointer to function called when input source changes. void (*pFuncOnInputSourceChange)(InputSource) = nullptr; // ----------------------------------------------------------------------------- // MiniDSP state. Currently only volume and muted status are // implemented, but others can be added easily if needed. // The volume is stored as an unsigned integer that represents twice the // -dB value. Example: 19 represents -9.5dB. uint8_t volume = 0; bool muted = false; InputSource inputSource = InputSource::UNKNOWN; };