diff --git a/docs/flashing.md b/docs/flashing.md index 443fa3123e1..113d90ca38f 100644 --- a/docs/flashing.md +++ b/docs/flashing.md @@ -322,6 +322,29 @@ Flashing sequence: 3. Flash a .bin file 4. Reset the device into application mode (may be done automatically) +## WB32 DFU + +Some keyboards produced for several commercial brands (GMMK, Akko, MonsGeek, Inland) use this bootloader. The `wb32-dfu-updater` utility is bundled with [QMK MSYS](https://msys.qmk.fm/) and [Glorious's build of QMK Toolbox](https://www.gloriousgaming.com/blogs/guides-resources/gmmk-2-qmk-installation-guide). If neither of these flashing methods is available for your OS, you will likely need to [compile the CLI version from source](https://github.com/WestberryTech/wb32-dfu-updater). + +The `info.json` setting for this bootloader is `wb32-dfu`. + +Compatible flashers: + +* [Glorious's build of QMK Toolbox](https://www.gloriousgaming.com/blogs/guides-resources/gmmk-2-qmk-installation-guide) (recommended GUI) +* [wb32-dfu-updater_cli](https://github.com/WestberryTech/wb32-dfu-updater) / `:flash` target in QMK (recommended command line) + ``` + wb32-dfu-updater_cli -t -s 0x8000000 -D + ``` + +Flashing sequence: + +1. Enter the bootloader using any of the following methods: + * Tap the `QK_BOOT` keycode + * Press the `RESET` button on the PCB +2. Wait for the OS to detect the device +3. Flash a .bin file +4. Reset the device into application mode (may be done automatically) + ## tinyuf2 Keyboards may opt into supporting the tinyuf2 bootloader. This is currently only supported on F303/F401/F411. diff --git a/lib/python/qmk/constants.py b/lib/python/qmk/constants.py index 79740972996..d48353c8336 100644 --- a/lib/python/qmk/constants.py +++ b/lib/python/qmk/constants.py @@ -84,6 +84,7 @@ BOOTLOADER_VIDS_PIDS = { }, 'apm32-dfu': {("314b", "0106")}, 'gd32v-dfu': {("28e9", "0189")}, + 'wb32-dfu': {("342d", "dfa0")}, 'bootloadhid': {("16c0", "05df")}, 'usbasploader': {("16c0", "05dc")}, 'usbtinyisp': {("1782", "0c9f")}, diff --git a/lib/python/qmk/flashers.py b/lib/python/qmk/flashers.py index f83665d9acc..9ecb5e4b9c8 100644 --- a/lib/python/qmk/flashers.py +++ b/lib/python/qmk/flashers.py @@ -96,7 +96,7 @@ def _find_bootloader(): details = 'halfkay' else: details = 'qmk-hid' - elif bl == 'stm32-dfu' or bl == 'apm32-dfu' or bl == 'gd32v-dfu' or bl == 'kiibohd': + elif bl in {'apm32-dfu', 'gd32v-dfu', 'kiibohd', 'stm32-dfu'}: details = (vid, pid) else: details = None @@ -181,9 +181,18 @@ def _flash_dfu_util(details, file): cli.run(['dfu-util', '-a', '0', '-d', f'{details[0]}:{details[1]}', '-s', '0x08000000:leave', '-D', file], capture_output=False) +def _flash_wb32_dfu_updater(file): + if shutil.which('wb32-dfu-updater_cli'): + cmd = 'wb32-dfu-updater_cli' + else: + return True + + cli.run([cmd, '-t', '-s', '0x08000000', '-D', file], capture_output=False) + + def _flash_isp(mcu, programmer, file): programmer = 'usbasp' if programmer == 'usbasploader' else 'usbtiny' - # Check if the provide mcu has an avrdude-specific name, otherwise pass on what the user provided + # Check if the provided mcu has an avrdude-specific name, otherwise pass on what the user provided mcu = AVRDUDE_MCU.get(mcu, mcu) cli.run(['avrdude', '-p', mcu, '-c', programmer, '-U', f'flash:w:{file}:i'], capture_output=False) @@ -211,8 +220,11 @@ def flasher(mcu, file): return (True, "Please make sure 'teensy_loader_cli' or 'hid_bootloader_cli' is available on your system.") else: return (True, "Specifying the MCU with '-m' is necessary for HalfKay/HID bootloaders!") - elif bl == 'stm32-dfu' or bl == 'apm32-dfu' or bl == 'gd32v-dfu' or bl == 'kiibohd': + elif bl in {'apm32-dfu', 'gd32v-dfu', 'kiibohd', 'stm32-dfu'}: _flash_dfu_util(details, file) + elif bl == 'wb32-dfu': + if _flash_wb32_dfu_updater(file): + return (True, "Please make sure 'wb32-dfu-updater_cli' is available on your system.") elif bl == 'usbasploader' or bl == 'usbtinyisp': if mcu: _flash_isp(mcu, bl, file) diff --git a/platforms/test/drivers/audio_pwm.h b/platforms/test/drivers/audio_pwm.h new file mode 100644 index 00000000000..9a3fa88cec3 --- /dev/null +++ b/platforms/test/drivers/audio_pwm.h @@ -0,0 +1,16 @@ +// Copyright 2023 Google LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#pragma once diff --git a/platforms/test/drivers/audio_pwm_hardware.c b/platforms/test/drivers/audio_pwm_hardware.c new file mode 100644 index 00000000000..336e4f58449 --- /dev/null +++ b/platforms/test/drivers/audio_pwm_hardware.c @@ -0,0 +1,20 @@ +// Copyright 2023 Google LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include "audio.h" + +void audio_driver_initialize(void) {} +void audio_driver_start() {} +void audio_driver_stop() {} diff --git a/quantum/audio/audio.c b/quantum/audio/audio.c index 2570ad9cd1e..0300483a938 100644 --- a/quantum/audio/audio.c +++ b/quantum/audio/audio.c @@ -547,20 +547,39 @@ void audio_decrease_tempo(uint8_t tempo_change) { note_tempo -= tempo_change; } -// TODO in the int-math version are some bugs; songs sometimes abruptly end - maybe an issue with the timer/system-tick wrapping around? +/** + * Converts from units of 1/64ths of a beat to milliseconds. + * + * Round-off error is at most 1 millisecond. + * + * Conversion will never overflow for duration_bpm <= 699, provided that + * note_tempo is at least 10. This is quite a long duration, over ten beats. + * + * Beware that for duration_bpm > 699, the result may overflow uint16_t range + * when duration_bpm is large compared to note_tempo: + * + * duration_bpm * 60 * 1000 / (64 * note_tempo) > UINT16_MAX + * + * duration_bpm > (2 * 65535 / 1875) * note_tempo + * = 69.904 * note_tempo. + */ uint16_t audio_duration_to_ms(uint16_t duration_bpm) { -#if defined(__AVR__) - // doing int-math saves us some bytes in the overall firmware size, but the intermediate result is less accurate before being cast to/returned as uint - return ((uint32_t)duration_bpm * 60 * 1000) / (64 * note_tempo); - // NOTE: beware of uint16_t overflows when note_tempo is low and/or the duration is long -#else - return ((float)duration_bpm * 60) / (64 * note_tempo) * 1000; -#endif + return ((uint32_t)duration_bpm * 1875) / ((uint_fast16_t)note_tempo * 2); } + +/** + * Converts from units of milliseconds to 1/64ths of a beat. + * + * Round-off error is at most 1/64th of a beat. + * + * This conversion never overflows: since duration_ms <= UINT16_MAX = 65535 + * and note_tempo <= 255, the result is always in uint16_t range: + * + * duration_ms * 64 * note_tempo / 60 / 1000 + * <= 65535 * 2 * 255 / 1875 + * = 17825.52 + * <= UINT16_MAX. + */ uint16_t audio_ms_to_duration(uint16_t duration_ms) { -#if defined(__AVR__) - return ((uint32_t)duration_ms * 64 * note_tempo) / 60 / 1000; -#else - return ((float)duration_ms * 64 * note_tempo) / 60 / 1000; -#endif + return ((uint32_t)duration_ms * 2 * note_tempo) / 1875; } diff --git a/tests/audio/config.h b/tests/audio/config.h new file mode 100644 index 00000000000..d0c4ddadbd3 --- /dev/null +++ b/tests/audio/config.h @@ -0,0 +1,18 @@ +// Copyright 2023 Google LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#pragma once + +#include "test_common.h" diff --git a/tests/audio/test.mk b/tests/audio/test.mk new file mode 100644 index 00000000000..a2c71d95878 --- /dev/null +++ b/tests/audio/test.mk @@ -0,0 +1,16 @@ +# Copyright 2023 Google LLC +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +AUDIO_ENABLE = yes diff --git a/tests/audio/test_audio.cpp b/tests/audio/test_audio.cpp new file mode 100644 index 00000000000..ef34748b060 --- /dev/null +++ b/tests/audio/test_audio.cpp @@ -0,0 +1,118 @@ +// Copyright 2023 Google LLC +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#include +#include + +#include "gtest/gtest.h" +#include "keyboard_report_util.hpp" +#include "test_common.hpp" + +namespace { + +class AudioTest : public TestFixture { + public: + uint16_t infer_tempo() { + return audio_ms_to_duration(1875) / 2; + } +}; + +TEST_F(AudioTest, OnOffToggle) { + audio_on(); + EXPECT_TRUE(audio_is_on()); + + audio_off(); + EXPECT_FALSE(audio_is_on()); + + audio_toggle(); + EXPECT_TRUE(audio_is_on()); + + audio_toggle(); + EXPECT_FALSE(audio_is_on()); +} + +TEST_F(AudioTest, ChangeTempo) { + for (int tempo = 50; tempo <= 250; tempo += 50) { + audio_set_tempo(tempo); + EXPECT_EQ(infer_tempo(), tempo); + } + + audio_set_tempo(10); + audio_increase_tempo(25); + EXPECT_EQ(infer_tempo(), 35); + + audio_decrease_tempo(4); + EXPECT_EQ(infer_tempo(), 31); + + audio_increase_tempo(250); + EXPECT_EQ(infer_tempo(), 255); + + audio_set_tempo(9); + EXPECT_EQ(infer_tempo(), 10); + + audio_decrease_tempo(100); + EXPECT_EQ(infer_tempo(), 10); +} + +TEST_F(AudioTest, BpmConversion) { + const int tol = 1; + + audio_set_tempo(120); + // At 120 bpm, there are 2 beats per second, and a whole note is 500 ms. + EXPECT_NEAR(audio_duration_to_ms(64 /* whole note */), 500, tol); + EXPECT_NEAR(audio_ms_to_duration(500), 64, tol); + EXPECT_EQ(audio_duration_to_ms(0), 0); + EXPECT_EQ(audio_ms_to_duration(0), 0); + + audio_set_tempo(10); + // At 10 bpm, UINT16_MAX ms corresponds to 699/64 beats and is the longest + // duration that can be converted without overflow. + EXPECT_NEAR(audio_ms_to_duration(UINT16_MAX), 699, tol); + EXPECT_NEAR(audio_duration_to_ms(699), 65531, tol); + + audio_set_tempo(255); + // At 255 bpm, UINT16_MAX ms corresponds to 17825/64 beats and is the longest + // duration that can be converted without overflow. + EXPECT_NEAR(audio_ms_to_duration(UINT16_MAX), 17825, tol); + EXPECT_NEAR(audio_duration_to_ms(17825), 65533, tol); + + std::mt19937 rng(0 /*seed*/); + std::uniform_int_distribution dist_tempo(10, 255); + std::uniform_int_distribution dist_ms(0, UINT16_MAX); + + // Test bpm <-> ms conversions for random tempos and durations. + for (int trial = 0; trial < 50; ++trial) { + const int tempo = dist_tempo(rng); + const int duration_ms = dist_ms(rng); + SCOPED_TRACE("tempo " + testing::PrintToString(tempo) + ", duration " + testing::PrintToString(duration_ms) + " ms"); + + audio_set_tempo(tempo); + int duration_bpm = std::round((64.0f / (60.0f * 1000.0f)) * duration_ms * tempo); + ASSERT_NEAR(audio_ms_to_duration(duration_ms), duration_bpm, tol); + + int roundtrip_ms = std::round((60.0f * 1000.0f / 64.0f) * duration_bpm / tempo); + // Because of round-off error, duration_ms and roundtrip_ms may differ by + // about (60 * 1000 / 64) / tempo. + int roundtrip_tol = tol * (60.0f * 1000.0f / 64.0f) / tempo; + ASSERT_NEAR(roundtrip_ms, duration_ms, roundtrip_tol); + + // Only test converting back to ms if the result would be in uint16_t range. + if (roundtrip_ms <= UINT16_MAX) { + ASSERT_NEAR(audio_duration_to_ms(duration_bpm), roundtrip_ms, tol); + } + } +} + +} // namespace