specchioriflesso/USB_Host_Shield_2.0
1
Fork 0
mirror of https://github.com/felis/USB_Host_Shield_2.0.git synced 2024-03-22 11:31:26 +01:00
Code Issues Projects Releases Packages Wiki Activity

Review comments.

Browse source
This commit is contained in:
Dennis Frett 2021-02-04 23:40:22 +01:00
parent a4e9521c4a
commit df0a711a3a
3 changed files with 209 additions and 201 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

132
MiniDSP.cpp
View file

@ -14,104 +14,88 @@
#include "MiniDSP.h" #include "MiniDSP.h"
namespace { void MiniDSP::ParseHIDData(USBHID *hid __attribute__((unused)), bool is_rpt_id __attribute__((unused)), uint8_t len, uint8_t *buf) {
uint8_t RequestStatusOutputCommand[] = {0x05, 0xFF, 0xDA, 0x02};
uint8_t StatusInputCommand[]{0x05, 0xFF, 0xDA};
// Returns first byte of the sum of given bytes. constexpr uint8_t StatusInputCommand[]{0x05, 0xFF, 0xDA};
uint8_t Checksum(const uint8_t *data, uint16_t nbytes) {
uint64_t sum = 0;
for (uint16_t i = 0; i < nbytes; i++) {
sum += data[i];
}
return sum & 0xFF; // Only care about valid data for the MiniDSP 2x4HD.
} if (HIDUniversal::VID != MINIDSP_VID || HIDUniversal::PID != MINIDSP_PID || len <= 4 || buf == nullptr)
} // namespace return;
void MiniDSP::ParseHIDData(USBHID *hid __attribute__((unused)), // Check if this is a status update.
bool is_rpt_id __attribute__((unused)), uint8_t len, // First byte is the length, we ignore that for now.
uint8_t *buf) { if (memcmp(buf + 1, StatusInputCommand, sizeof(StatusInputCommand)) == 0) {
// Only care about valid data for the MiniDSP 2x4HD. // Parse data.
if (HIDUniversal::VID != MINIDSP_VID || HIDUniversal::PID != MINIDSP_PID || // Response is of format [ length ] [ 0x05 0xFF 0xDA ] [ volume ] [ muted ].
len <= 2 || buf == nullptr) { const auto newVolume = buf[sizeof(StatusInputCommand) + 1];
return; const auto newIsMuted = (bool)buf[sizeof(StatusInputCommand) + 2];
}
// Check if this is a status update. // Update status.
// First byte is the length, we ignore that for now. volume = newVolume;
if (memcmp(buf + 1, StatusInputCommand, sizeof(StatusInputCommand)) == 0) { muted = newIsMuted;
// Parse data. // Call callbacks.
// Response is of format [ length ] [ 0x05 0xFF 0xDA ] [ volume ] [ muted ]. if (pFuncOnVolumeChange != nullptr && newVolume != volume)
const auto newVolume = buf[sizeof(StatusInputCommand) + 1]; pFuncOnVolumeChange(volume);
const auto newIsMuted = (bool)buf[sizeof(StatusInputCommand) + 2];
const auto volumeUpdated = newVolume != volume; if (pFuncOnMutedChange != nullptr && newIsMuted != muted)
const auto isMutedUpdated = newIsMuted != isMuted; pFuncOnMutedChange(muted);
}
// Update status.
volume = newVolume;
isMuted = newIsMuted;
// Call callbacks.
if (volumeChangeCallback != nullptr && volumeUpdated) {
volumeChangeCallback(volume);
}
if (mutedChangeCallback != nullptr && isMutedUpdated) {
mutedChangeCallback(isMuted);
}
}
}; };
uint8_t MiniDSP::OnInitSuccessful() { uint8_t MiniDSP::OnInitSuccessful() {
// Verify we're actually connected to the MiniDSP 2x4HD. // Verify we're actually connected to the MiniDSP 2x4HD.
if (HIDUniversal::VID != MINIDSP_VID || HIDUniversal::PID != MINIDSP_PID) { if (HIDUniversal::VID != MINIDSP_VID || HIDUniversal::PID != MINIDSP_PID)
return 0; return 0;
}
// Request current status so we can initialize the values. // Request current status so we can initialize the values.
RequestStatus(); RequestStatus();
if (onInitCallback != nullptr) { if (pFuncOnInit != nullptr)
onInitCallback(); pFuncOnInit();
}
return 0; return 0;
}; };
void MiniDSP::SendCommand(uint8_t *command, uint16_t command_length) const { uint8_t MiniDSP::Checksum(const uint8_t *data, uint8_t data_length) const {
// Only send command if we're actually connected to the MiniDSP 2x4HD. uint16_t sum = 0;
if (HIDUniversal::VID != MINIDSP_VID || HIDUniversal::PID != MINIDSP_PID) { for (uint8_t i = 0; i < data_length; i++)
return; sum += data[i];
}
// Message is padded to 64 bytes with 0xFF and is of format: return sum & 0xFF;
// [ length (command + checksum byte) ] [ command ] [ checksum ] [ OxFF... ] }
// MiniDSP expects 64 byte messages. void MiniDSP::SendCommand(uint8_t *command, uint8_t command_length) const {
uint8_t buf[64]; // Sanity check on command length.
if (command_length > 63)
return;
// Set length, including checksum byte. // Message is padded to 64 bytes with 0xFF and is of format:
buf[0] = command_length + 1; // [ length (command + checksum byte) ] [ command ] [ checksum ] [ OxFF... ]
// Copy actual command. // MiniDSP expects 64 byte messages.
memcpy(&buf[1], command, command_length); uint8_t buf[64];
const auto checksumOffset = command_length + 1; // Set length, including checksum byte.
buf[0] = command_length + 1;
// Set checksum byte. // Copy actual command.
buf[checksumOffset] = Checksum(buf, command_length + 1); memcpy(&buf[1], command, command_length);
// Pad the rest. const auto checksumOffset = command_length + 1;
memset(&buf[checksumOffset + 1], 0xFF, sizeof(buf) - checksumOffset - 1);
pUsb->outTransfer(bAddress, epInfo[epInterruptOutIndex].epAddr, sizeof(buf), // Set checksum byte.
buf); buf[checksumOffset] = Checksum(buf, command_length + 1);
// Pad the rest.
memset(&buf[checksumOffset + 1], 0xFF, sizeof(buf) - checksumOffset - 1);
pUsb->outTransfer(bAddress, epInfo[epInterruptOutIndex].epAddr, sizeof(buf), buf);
} }
void MiniDSP::RequestStatus() const { void MiniDSP::RequestStatus() const {
SendCommand(RequestStatusOutputCommand, sizeof(RequestStatusOutputCommand)); uint8_t RequestStatusOutputCommand[] = {0x05, 0xFF, 0xDA, 0x02};
SendCommand(RequestStatusOutputCommand, sizeof(RequestStatusOutputCommand));
} }

234
MiniDSP.h
View file

@ -14,7 +14,6 @@
#pragma once #pragma once
#include "controllerEnums.h"
#include "hiduniversal.h" #include "hiduniversal.h"
#define MINIDSP_VID 0x2752 // MiniDSP #define MINIDSP_VID 0x2752 // MiniDSP
@ -31,127 +30,150 @@
* It uses the HIDUniversal class for all the USB communication. * It uses the HIDUniversal class for all the USB communication.
*/ */
class MiniDSP : public HIDUniversal { class MiniDSP : public HIDUniversal {
public: public:
/** /**
* Constructor for the MiniDSP class. * Constructor for the MiniDSP class.
* @param p Pointer to the USB class instance. * @param p Pointer to the USB class instance.
*/ */
MiniDSP(USB *p) : HIDUniversal(p){}; MiniDSP(USB *p) : HIDUniversal(p){};
/** /**
* Used to check if a MiniDSP 2x4HD is connected. * Used to check if a MiniDSP 2x4HD is connected.
* @return Returns true if it is connected. * @return Returns true if it is connected.
*/ */
bool connected() { bool connected() {
return HIDUniversal::isReady() && HIDUniversal::VID == MINIDSP_VID && return HIDUniversal::isReady() && HIDUniversal::VID == MINIDSP_VID && HIDUniversal::PID == MINIDSP_PID;
HIDUniversal::PID == MINIDSP_PID; };
};
/** /**
* Used to call your own function when the device is successfully initialized. * Used to call your own function when the device is successfully
* @param func Function to call. * initialized.
*/ * @param funcOnInit Function to call.
void SetOnInitCallback(void (*func)(void)) { onInitCallback = func; }; */
void attachOnInit(void (*funcOnInit)(void)) { pFuncOnInit = funcOnInit; };
/** /**
* Used to call your own function when the volume has changed. * Used to call your own function when the volume has changed.
* The volume is passed as an unsigned integer that represents twice the -dB * The volume is passed as an unsigned integer that represents twice the
* value. Example: 19 represents -9.5dB. * -dB value. Example: 19 represents -9.5dB.
* @param func Function to call. * @param funcOnVolumeChange Function to call.
*/ */
void SetVolumeChangeCallback(void (*func)(uint8_t)) { void attachOnVolumeChange(void (*funcOnVolumeChange)(uint8_t)) {
volumeChangeCallback = func; pFuncOnVolumeChange = funcOnVolumeChange;
} }
/** /**
* Used to call your own function when the muted status has changed. * 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 * The muted status is passed as a boolean. True means muted, false
* unmuted. * means unmuted.
* @param func Function to call. * @param funcOnMutedChange Function to call.
*/ */
void SetMutedChangeCallback(void (*func)(bool)) { void attachOnMutedChange(void (*funcOnMutedChange)(bool)) {
mutedChangeCallback = func; pFuncOnMutedChange = funcOnMutedChange;
} }
/** /**
* Retrieve the current volume of the MiniDSP. * Retrieve the current volume of the MiniDSP.
* The volume is passed as an unsigned integer that represents twice the -dB * The volume is passed as an unsigned integer that represents twice the
* value. Example: 19 represents -9.5dB. * -dB value. Example: 19 represents -9.5dB.
* @return Current volume. * @return Current volume.
*/ */
int GetVolume() const { return volume; } int getVolume() const {
return volume;
}
/** /**
* Retrieve the current muted status of the MiniDSP * Retrieve the current volume of the MiniDSP in -dB.
* @return `true` if the device is muted, `false` otherwise. * @return Current volume.
*/ */
bool IsMuted() const { return isMuted; } float getVolumeDB() const {
return volume / -2.0;
}
protected: /**
/** @name HIDUniversal implementation */ * Retrieve the current muted status of the MiniDSP
/** * @return `true` if the device is muted, `false` otherwise.
* Used to parse USB HID data. */
* @param hid Pointer to the HID class. bool isMuted() const {
* @param is_rpt_id Only used for Hubs. return muted;
* @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);
/** protected:
* Called when a device is successfully initialized. /** @name HIDUniversal implementation */
* 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. * Used to parse USB HID data.
*/ * @param hid Pointer to the HID class.
uint8_t OnInitSuccessful(); * @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);
/** @name USBDeviceConfig implementation */ /**
/** * Called when a device is successfully initialized.
* Used by the USB core to check what this driver support. * Use attachOnInit(void (*funcOnInit)(void)) to call your own function.
* @param vid The device's VID. * This is useful for instance if you want to set the LEDs in a specific
* @param pid The device's PID. * way.
* @return Returns true if the device's VID and PID matches this driver. */
*/ uint8_t OnInitSuccessful();
virtual bool VIDPIDOK(uint16_t vid, uint16_t pid) { /**@}*/
return vid == MINIDSP_VID && pid == MINIDSP_PID;
};
/**@}*/
private: /** @name USBDeviceConfig implementation */
/** /**
* Send the "Request status" command to the MiniDSP. The response includes the * Used by the USB core to check what this driver support.
* current volume and the muted status. * @param vid The device's VID.
*/ * @param pid The device's PID.
void RequestStatus() const; * @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:
* 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 * Calculate checksum for given buffer.
* come in throug `ParseHIDData`. * Checksum is given by summing up all bytes in `data` and returning the first byte.
* @param command Buffer of the command to send. * @param data Buffer to calculate checksum for.
* @param command_length Length of the buffer. * @param data_length Length of the buffer.
*/ */
void SendCommand(uint8_t *command, uint16_t command_length) const; uint8_t Checksum(const uint8_t *data, uint8_t data_length) const;
// Callbacks /**
* Send the "Request status" command to the MiniDSP. The response
* includes the current volume and the muted status.
*/
void
RequestStatus() const;
// Pointer to function called in onInit(). /**
void (*onInitCallback)(void) = nullptr; * 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;
// Pointer to function called when volume changes. // Callbacks
void (*volumeChangeCallback)(uint8_t) = nullptr;
// Pointer to function called when muted status changes. // Pointer to function called in onInit().
void (*mutedChangeCallback)(bool) = nullptr; void (*pFuncOnInit)(void) = nullptr;
// ----------------------------------------------------------------------------- // Pointer to function called when volume changes.
void (*pFuncOnVolumeChange)(uint8_t) = nullptr;
// MiniDSP state. Currently only volume and muted status are implemented, but // Pointer to function called when muted status changes.
// others can be added easily if needed. void (*pFuncOnMutedChange)(bool) = nullptr;
// The volume is stored as an unsigned integer that represents twice the // -----------------------------------------------------------------------------
// -dB value. Example: 19 represents -9.5dB.
uint8_t volume = 0; // MiniDSP state. Currently only volume and muted status are
bool isMuted = false; // 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;
}; };

44
examples/MiniDSP/MiniDSP.ino
View file

@ -1,7 +1,5 @@
/* /*
Example sketch for the Playstation Buzz library - developed by Kristian Lauszus Example sketch for the MiniDSP 2x4HD library - developed by Dennis Frett
For more information visit my blog: http://blog.tkjelectronics.dk/ or
send me an e-mail: kristianl@tkjelectronics.com
*/ */
#include <MiniDSP.h> #include <MiniDSP.h>
@ -15,34 +13,38 @@
USB Usb; USB Usb;
MiniDSP MiniDSP(&Usb); MiniDSP MiniDSP(&Usb);
void OnMiniDSPConnected() { Serial.println("MiniDSP connected"); } void OnMiniDSPConnected() {
Serial.println("MiniDSP connected");
}
void OnVolumeChange(uint8_t volume) { void OnVolumeChange(uint8_t volume) {
Serial.println("Volume is: " + String(volume)); Serial.println("Volume is: " + String(volume));
} }
void OnMutedChange(bool isMuted) { void OnMutedChange(bool isMuted) {
Serial.println("Muted status: " + String(isMuted ? "muted" : "unmuted")); Serial.println("Muted status: " + String(isMuted ? "muted" : "unmuted"));
} }
void setup() { void setup() {
Serial.begin(115200); Serial.begin(115200);
#if !defined(__MIPSEL__) #if !defined(__MIPSEL__)
while (!Serial) while (!Serial)
; // Wait for serial port to connect - used on Leonardo, Teensy and other ; // Wait for serial port to connect - used on Leonardo, Teensy and other
// boards with built-in USB CDC serial connection // boards with built-in USB CDC serial connection
#endif #endif
if (Usb.Init() == -1) { if (Usb.Init() == -1) {
Serial.print(F("\r\nOSC did not start")); Serial.print(F("\r\nOSC did not start"));
while (1) while (1)
; // Halt ; // Halt
} }
Serial.println(F("\r\nMiniDSP 2x4HD Library Started")); Serial.println(F("\r\nMiniDSP 2x4HD Library Started"));
// Register callbacks. // Register callbacks.
MiniDSP.SetOnInitCallback(&OnMiniDSPConnected); MiniDSP.attachOnInit(&OnMiniDSPConnected);
MiniDSP.SetVolumeChangeCallback(&OnVolumeChange); MiniDSP.attachOnVolumeChange(&OnVolumeChange);
MiniDSP.SetMutedChangeCallback(&OnMutedChange); MiniDSP.attachOnMutedChange(&OnMutedChange);
} }
void loop() { Usb.Task(); } void loop() {
Usb.Task();
}