wirtz
/
uClock
mirror of https://github.com/midilab/uClock
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #32 from midilab/v2-release

Browse Source 
V2 release beta
pull/34/head
midilab 10 months ago committed by GitHub
parent a3aeae9c83 459ae7f4e6
commit 5be9c088c7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 378 additions and 265 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 59
      README.md
  2. 2
      library.json
  3. 2
      library.properties
  4. 2
      src/platforms/esp32.h
  5. 273
      src/uClock.cpp
  6. 151
      src/uClock.h

59
README.md
Unescape View File

@ -9,15 +9,50 @@ The absence of real-time features necessary for creating professional-level embe
With uClock, you gain the ability to create professional-grade sequencers, sync boxes, or generate a precise BPM clock for external devices in the realms of music, audio/video productions, performances, or tech art installations. The library offers an external synchronization schema that enables you to generate an internal clock based on an external clock source, allowing you to master your entire MIDI setup or any other protocols according to your specific preferences and requirements. With uClock, you gain the ability to create professional-grade sequencers, sync boxes, or generate a precise BPM clock for external devices in the realms of music, audio/video productions, performances, or tech art installations. The library offers an external synchronization schema that enables you to generate an internal clock based on an external clock source, allowing you to master your entire MIDI setup or any other protocols according to your specific preferences and requirements.
## Interface ## Interface
The uClock library interfaces through an attached callback function that runs on a hardware interrupt and provides support for the following resolutions: The uClock library API operates through attached callback functions mechanism:
1. **16PPQN** 16 Pulses Per Quarter Note 1. **onPPQNCallback(uint32_t tick)** calls on each new pulse based on selected PPQN resolution(if no PPQN set, the default is 96PPQN)
2. **32PPQN** 32 Pulses Per Quarter Note 2. **onStepCallback(uint32_t step)** good way to code old style step sequencer based on 16th note schema(not dependent on PPQN resolution)
3. **96PPQN** 96 Pulses Per Quarter Note 3. **onSync24Callback(uint32_t tick)** good way to code a clock machine, or keep your gears synced with your device
4. **onSync48Callback(uint32_t tick)** there are some 48ppqn based sync devices out there
5. **onClockStartCallback()** on uClock Start event
6. **onClockStopCallback()** on uClock Stop event
To generate a MIDI sync signal and synchronize external MIDI devices, you can start working with the resolution of 96PPQN, which aligns with the clocking standards of modern MIDI-syncable devices commonly available in the market. This resolution is based on the 24PPQN (24 multiplied by 4 equals 96). By sending a sync signal every 96PPQN interval, you can ensure effective synchronization among your MIDI devices. ```c++
#include <uClock.h>
void setup() {
// avaliable resolutions
// [ uClock.PPQN_24, uClock.PPQN_48, uClock.PPQN_96, uClock.PPQN_384, uClock.PPQN_480, uClock.PPQN_960 ]
// not mandatory to call, the default is 96PPQN if not set
uClock.setPPQN(uClock.PPQN_96);
// you need to use at least one!
uClock.setOnPPQN(onPPQNCallback);
uClock.setOnStep(onStepCallback);
uClock.setOnSync24(onSync24Callback);
uClock.setOnSync48(onSync48Callback);
uClock.setOnClockStart(onClockStartCallback);
uClock.setOnClockStop(onClockStopCallback);
uClock.init();
}
```
Resolutions: set youw own resolution for your clock needs
1. **PPQN_24** 24 Pulses Per Quarter Note
2. **PPQN_48** 48 Pulses Per Quarter Note
3. **PPQN_96** 96 Pulses Per Quarter Note
1. **PPQN_384** 384 Pulses Per Quarter Note
2. **PPQN_480** 480 Pulses Per Quarter Note
3. **PPQN_960** 96 Pulses Per Quarter Note
To generate a MIDI sync signal and synchronize external MIDI devices, you can start working with the resolution of 24PPQN, which aligns with the clocking standards of modern MIDI-syncable devices commonly available in the market. By sending 24 pulses per quarter note interval, you can ensure effective synchronization among your MIDI devices.
If you are working on the development of a vintage-style step sequencer, utilizing a resolution of 16PPQN is a fitting option to initiate the coding process. This resolution ensures that each 16PPQN call corresponds to a step played note or event. If you are working on the development of a vintage-style step sequencer, utilizing a resolution of 96PPQN is a fitting option to initiate the coding process. Then you can use onStepCallback call wich corresponds to a step played note or event.
Furthermore, it is possible to utilize all three resolutions simultaneously, allowing for flexibility based on your specific requirements and preferences. Furthermore, it is possible to utilize all three resolutions simultaneously, allowing for flexibility based on your specific requirements and preferences.
@ -38,7 +73,7 @@ Here is an example on how to create a simple MIDI Sync Box on Arduino boards
#define MIDI_STOP 0xFC #define MIDI_STOP 0xFC
// The callback function wich will be called by Clock each Pulse of 96PPQN clock resolution. // The callback function wich will be called by Clock each Pulse of 96PPQN clock resolution.
void ClockOut96PPQN(uint32_t tick) { void onSync24Callback(uint32_t tick) {
// Send MIDI_CLOCK to external gears // Send MIDI_CLOCK to external gears
Serial.write(MIDI_CLOCK); Serial.write(MIDI_CLOCK);
} }
@ -60,8 +95,8 @@ void setup() {
// Inits the clock // Inits the clock
uClock.init(); uClock.init();
// Set the callback function for the clock output to send MIDI Sync message. // Set the callback function for the clock output to send MIDI Sync message based on 24PPQN
uClock.setClock96PPQNOutput(ClockOut96PPQN); uClock.setOnSync24(onSync24Callback);
// Set the callback function for MIDI Start and Stop messages. // Set the callback function for MIDI Start and Stop messages.
uClock.setOnClockStartOutput(onClockStart); uClock.setOnClockStartOutput(onClockStart);
uClock.setOnClockStopOutput(onClockStop); uClock.setOnClockStopOutput(onClockStop);
@ -85,7 +120,7 @@ An example on how to create a simple MIDI Sync Box on Teensy boards and USB Midi
#include <uClock.h> #include <uClock.h>
// The callback function wich will be called by Clock each Pulse of 96PPQN clock resolution. // The callback function wich will be called by Clock each Pulse of 96PPQN clock resolution.
void ClockOut96PPQN(uint32_t tick) { void onSync24Callback(uint32_t tick) {
// Send MIDI_CLOCK to external gears // Send MIDI_CLOCK to external gears
usbMIDI.sendRealTime(usbMIDI.Clock); usbMIDI.sendRealTime(usbMIDI.Clock);
} }
@ -103,8 +138,8 @@ void onClockStop() {
void setup() { void setup() {
// Inits the clock // Inits the clock
uClock.init(); uClock.init();
// Set the callback function for the clock output to send MIDI Sync message. // Set the callback function for the clock output to send MIDI Sync message. based on 24PPQN
uClock.setClock96PPQNOutput(ClockOut96PPQN); uClock.setOnSync24(onSync24Callback);
// Set the callback function for MIDI Start and Stop messages. // Set the callback function for MIDI Start and Stop messages.
uClock.setOnClockStartOutput(onClockStart); uClock.setOnClockStartOutput(onClockStart);
uClock.setOnClockStopOutput(onClockStop); uClock.setOnClockStopOutput(onClockStop);

2
library.json
Unescape View File

@ -1,6 +1,6 @@
{ {
"name": "uClock", "name": "uClock",
"version": "1.5.1", "version": "2.0.0",
"description": "A Library to implement BPM clock tick calls using hardware interruption. Supported and tested on AVR boards(ATmega168/328, ATmega16u4/32u4 and ATmega2560) and ARM boards(Teensy, Seedstudio XIAO M0. ESP32 and STM32)", "description": "A Library to implement BPM clock tick calls using hardware interruption. Supported and tested on AVR boards(ATmega168/328, ATmega16u4/32u4 and ATmega2560) and ARM boards(Teensy, Seedstudio XIAO M0. ESP32 and STM32)",
"keywords": "bpm, clock, timing, tick, music, generator", "keywords": "bpm, clock, timing, tick, music, generator",
"repository": "repository":

2
library.properties
Unescape View File

@ -1,5 +1,5 @@
name=uClock name=uClock
version=1.5.1 version=2.0.0
author=Romulo Silva <contact@midilab.co> author=Romulo Silva <contact@midilab.co>
maintainer=Romulo Silva <contact@midilab.co> maintainer=Romulo Silva <contact@midilab.co>
sentence=BPM clock generator for Arduino platform. sentence=BPM clock generator for Arduino platform.

2
src/platforms/esp32.h
Unescape View File

@ -9,7 +9,7 @@ hw_timer_t * _uclockTimer = NULL;
//#define ATOMIC(X) portENTER_CRITICAL_ISR(&_uclockTimerMux); X; portEXIT_CRITICAL_ISR(&_uclockTimerMux); //#define ATOMIC(X) portENTER_CRITICAL_ISR(&_uclockTimerMux); X; portEXIT_CRITICAL_ISR(&_uclockTimerMux);
// FreeRTOS main clock task size in bytes // FreeRTOS main clock task size in bytes
#define CLOCK_STACK_SIZE 5012 // adjust for your needs, a sequencer with heavy serial handling should be large in size #define CLOCK_STACK_SIZE 5*1024 // adjust for your needs, a sequencer with heavy serial handling should be large in size
TaskHandle_t taskHandle; TaskHandle_t taskHandle;
// mutex to protect the shared resource // mutex to protect the shared resource
SemaphoreHandle_t _mutex; SemaphoreHandle_t _mutex;

273
src/uClock.cpp
Unescape View File

@ -2,10 +2,10 @@
* @file uClock.cpp * @file uClock.cpp
* Project BPM clock generator for Arduino * Project BPM clock generator for Arduino
* @brief A Library to implement BPM clock tick calls using hardware interruption. Supported and tested on AVR boards(ATmega168/328, ATmega16u4/32u4 and ATmega2560) and ARM boards(Teensy, Seedstudio XIAO M0 and ESP32) * @brief A Library to implement BPM clock tick calls using hardware interruption. Supported and tested on AVR boards(ATmega168/328, ATmega16u4/32u4 and ATmega2560) and ARM boards(Teensy, Seedstudio XIAO M0 and ESP32)
* @version 1.5.1 * @version 2.0.0
* @author Romulo Silva * @author Romulo Silva
* @date 10/06/2017 * @date 10/06/2017
* @license MIT - (c) 2022 - Romulo Silva - contact@midilab.co * @license MIT - (c) 2024 - Romulo Silva - contact@midilab.co
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -66,15 +66,13 @@
// header of this file // header of this file
void uclockInitTimer() void uclockInitTimer()
{ {
// begin at 120bpm (20833us) // begin at 120bpm
initTimer(20833); initTimer(uClock.bpmToMicroSeconds(120.00));
} }
void setTimerTempo(float bpm) void setTimerTempo(float bpm)
{ {
// convert bpm float into 96 ppqn resolution microseconds interval setTimer(uClock.bpmToMicroSeconds(bpm));
uint32_t us_interval = (60000000 / 24 / bpm);
setTimer(us_interval);
} }
namespace umodular { namespace clock { namespace umodular { namespace clock {
@ -103,11 +101,14 @@ uClockClass::uClockClass()
mode = INTERNAL_CLOCK; mode = INTERNAL_CLOCK;
resetCounters(); resetCounters();
onClock96PPQNCallback = NULL; onPPQNCallback = nullptr;
onClock32PPQNCallback = NULL; onSync24Callback = nullptr;
onClock16PPQNCallback = NULL; onSync48Callback = nullptr;
onClockStartCallback = NULL; onStepCallback = nullptr;
onClockStopCallback = NULL; onClockStartCallback = nullptr;
onClockStopCallback = nullptr;
// first ppqn references calculus
setPPQN(PPQN_96);
} }
void uClockClass::init() void uClockClass::init()
@ -117,6 +118,23 @@ void uClockClass::init()
setTempo(tempo); setTempo(tempo);
} }
uint32_t uClockClass::bpmToMicroSeconds(float bpm)
{
return (60000000 / ppqn / bpm);
}
void uClockClass::setPPQN(PPQNResolution resolution)
{
// stop clock to make it safe changing those references
// so we avoid volatile then and ATOMIC everyone
stop();
ppqn = resolution;
// calculate the mod24, mod48 and mod_step tick reference trigger
mod24_ref = ppqn / 24;
mod48_ref = ppqn / 48;
mod_step_ref = ppqn / 4;
}
void uClockClass::start() void uClockClass::start()
{ {
resetCounters(); resetCounters();
@ -169,20 +187,19 @@ void uClockClass::setTempo(float bpm)
) )
setTimerTempo(bpm); setTimerTempo(bpm);
} }
float inline uClockClass::freqToBpm(uint32_t freq) float inline uClockClass::freqToBpm(uint32_t freq)
{ {
float usecs = 1/((float)freq/1000000.0); float usecs = 1/((float)freq/1000000.0);
return (float)((float)(usecs/24.0) * 60.0); return (float)((float)(usecs/(float)ppqn) * 60.0);
} }
float uClockClass::getTempo() float uClockClass::getTempo()
{ {
if (mode == EXTERNAL_CLOCK) { if (mode == EXTERNAL_CLOCK) {
uint32_t acc = 0; uint32_t acc = 0;
// wait the buffer get full // wait the buffer to get full
if (ext_interval_buffer[EXT_INTERVAL_BUFFER_SIZE-1] == 0) { if (ext_interval_buffer[EXT_INTERVAL_BUFFER_SIZE-1] == 0) {
return tempo; return tempo;
} }
@ -196,7 +213,7 @@ float uClockClass::getTempo()
return tempo; return tempo;
} }
void uClockClass::setMode(uint8_t tempo_mode) void uClockClass::setMode(SyncMode tempo_mode)
{ {
mode = tempo_mode; mode = tempo_mode;
} }
@ -217,16 +234,16 @@ void uClockClass::clockMe()
void uClockClass::resetCounters() void uClockClass::resetCounters()
{ {
external_clock = 0; tick = 0;
internal_tick = 0; int_clock_tick = 0;
external_tick = 0; sync48_tick = 0;
div32th_counter = 0; ext_clock_tick = 0;
div16th_counter = 0; ext_clock_us = 0;
mod6_counter = 0;
indiv32th_counter = 0;
indiv16th_counter = 0;
inmod6_counter = 0;
ext_interval_idx = 0; ext_interval_idx = 0;
mod24_counter = 0;
mod48_counter = 0;
mod_step_counter = 0;
step_counter = 0;
for (uint8_t i=0; i < EXT_INTERVAL_BUFFER_SIZE; i++) { for (uint8_t i=0; i < EXT_INTERVAL_BUFFER_SIZE; i++) {
ext_interval_buffer[i] = 0; ext_interval_buffer[i] = 0;
} }
@ -262,9 +279,9 @@ void uClockClass::setShuffleData(uint8_t step, int8_t tick)
ATOMIC(shuffle.step[step] = tick) ATOMIC(shuffle.step[step] = tick)
} }
void uClockClass::setShuffleTemplate(int8_t * shuff) void uClockClass::setShuffleTemplate(int8_t * shuff, uint8_t size)
{ {
uint8_t size = sizeof(shuff) / sizeof(shuff[0]); //uint8_t size = sizeof(shuff) / sizeof(shuff[0]);
if (size > MAX_SHUFFLE_TEMPLATE_SIZE) if (size > MAX_SHUFFLE_TEMPLATE_SIZE)
size = MAX_SHUFFLE_TEMPLATE_SIZE; size = MAX_SHUFFLE_TEMPLATE_SIZE;
ATOMIC(shuffle.size = size) ATOMIC(shuffle.size = size)
@ -278,72 +295,84 @@ int8_t uClockClass::getShuffleLength()
return shuffle_length_ctrl; return shuffle_length_ctrl;
} }
int8_t inline uClockClass::processShuffle() bool inline uClockClass::processShuffle()
{ {
int8_t mod6_shuffle_counter;
if (!shuffle.active) { if (!shuffle.active) {
mod6_shuffle_counter = mod6_counter; return mod_step_counter == 0;
} else { }
// apply shuffle template to step
int8_t shff = shuffle.step[div16th_counter%shuffle.size]; // internal reference for mod_counter
// keep track of next note shuffle for current note lenght control uint8_t mod_counter = mod_step_ref - (mod_step_counter == 0 ? mod_step_ref : mod_step_counter);
shuffle_length_ctrl = shuffle.step[(div16th_counter+1)%shuffle.size]; int8_t mod_shuffle = 0;
// prepare the next mod6 quantize to be called
if (shff == 0) { // check shuffle template to step
mod6_shuffle_counter = mod6_counter; int8_t shff = shuffle.step[step_counter%shuffle.size];
} else if (shff > 0) {
if (shuffle_shoot_ctrl == false && mod6_counter > shff || (shff == 5 && mod6_counter == 0)) if (shuffle_shoot_ctrl == false && mod_counter == 0)
shuffle_shoot_ctrl = true; shuffle_shoot_ctrl = true;
mod6_shuffle_counter = shuffle_shoot_ctrl ? mod6_counter - shff : 1;
shuffle_length_ctrl -= shff; //if (mod_counter == mod_step_ref-1)
if (shuffle_length_ctrl == 0)
shuffle_length_ctrl = 1; if (shff >= 0) {
mod_shuffle = mod_counter - shff;
// any late shuffle? we should skip next mod_counter == 0
if (last_shff < 0 && mod_counter != 1)
return false;
} else if (shff < 0) { } else if (shff < 0) {
if (shuffle_shoot_ctrl == false && mod6_counter == 0) mod_shuffle = mod_counter - (mod_step_ref + shff);
//if (last_shff < 0 && mod_counter != 1)
// return false;
shuffle_shoot_ctrl = true; shuffle_shoot_ctrl = true;
mod6_shuffle_counter = shff - mod6_counter == -6 ? shuffle_shoot_ctrl ? 0 : 1 : 1;
shuffle_length_ctrl += shff;
if (shuffle_length_ctrl == 0)
shuffle_length_ctrl = -1;
} }
//Serial.println("-----------------");
//Serial.print("shff: ");
//Serial.println(shff);
//Serial.print("mod_counter: ");
//Serial.println(mod_counter);
//Serial.print("mod_shuffle: ");
//Serial.println(mod_shuffle);
//Serial.print("shuffle_shoot_ctrl: ");
//Serial.println(shuffle_shoot_ctrl);
//Serial.print("last_shff: ");
//Serial.println(last_shff);
last_shff = shff;
// shuffle_shoot_ctrl helps keep track if we have shoot or not a note for the step space of ppqn/4 pulses
if (mod_shuffle == 0 && shuffle_shoot_ctrl == true) {
// keep track of next note shuffle for current note lenght control
shuffle_length_ctrl = shuffle.step[(step_counter+1)%shuffle.size];
if (shff > 0)
shuffle_length_ctrl -= shff;
if (shff < 0)
shuffle_length_ctrl += shff;
shuffle_shoot_ctrl = false;
return true;
} }
return mod6_shuffle_counter;
return false;
} }
// it is expected to be called in 24PPQN
void uClockClass::handleExternalClock() void uClockClass::handleExternalClock()
{ {
switch (state) { switch (state) {
case PAUSED: case PAUSED:
break; break;
case STARTING: case STARTING:
state = STARTED; state = STARTED;
external_clock = micros(); ext_clock_us = micros();
break; break;
case STARTED: case STARTED:
uint32_t now_clock_us = micros();
last_interval = clock_diff(ext_clock_us, now_clock_us);
ext_clock_us = now_clock_us;
uint32_t u_timer = micros(); // external clock tick me!
last_interval = clock_diff(external_clock, u_timer); ext_clock_tick++;
external_clock = u_timer;
if (inmod6_counter == 0) {
indiv16th_counter++;
indiv32th_counter++;
}
if (inmod6_counter == 3) {
indiv32th_counter++;
}
// slave tick me!
external_tick++;
inmod6_counter++;
if (inmod6_counter == 6) {
inmod6_counter = 0;
}
// accumulate interval incomming ticks data for getTempo() smooth reads on slave mode // accumulate interval incomming ticks data for getTempo() smooth reads on slave mode
if(++ext_interval_idx >= EXT_INTERVAL_BUFFER_SIZE) { if(++ext_interval_idx >= EXT_INTERVAL_BUFFER_SIZE) {
@ -351,10 +380,10 @@ void uClockClass::handleExternalClock()
} }
ext_interval_buffer[ext_interval_idx] = last_interval; ext_interval_buffer[ext_interval_idx] = last_interval;
if (external_tick == 1) { if (ext_clock_tick == 1) {
interval = last_interval; ext_interval = last_interval;
} else { } else {
interval = (((uint32_t)interval * (uint32_t)PLL_X) + (uint32_t)(256 - PLL_X) * (uint32_t)last_interval) >> 8; ext_interval = (((uint32_t)ext_interval * (uint32_t)PLL_X) + (uint32_t)(256 - PLL_X) * (uint32_t)last_interval) >> 8;
} }
break; break;
} }
@ -362,20 +391,20 @@ void uClockClass::handleExternalClock()
void uClockClass::handleTimerInt() void uClockClass::handleTimerInt()
{ {
// External sync is handled here... test if clock check on each tick instead when
// mod24_counter kicks in will help or worst slave timing sync quality
if (mod24_counter == 0) {
if (mode == EXTERNAL_CLOCK) { if (mode == EXTERNAL_CLOCK) {
// sync tick position with external tick clock // sync tick position with external tick clock
if ((internal_tick < external_tick) || (internal_tick > (external_tick + 1))) { if ((int_clock_tick < ext_clock_tick) || (int_clock_tick > (ext_clock_tick + 1))) {
internal_tick = external_tick; int_clock_tick = ext_clock_tick;
div32th_counter = indiv32th_counter;
div16th_counter = indiv16th_counter;
mod6_counter = inmod6_counter;
} }
uint32_t counter = interval; uint32_t counter = ext_interval;
uint32_t u_timer = micros(); uint32_t now_clock_us = micros();
sync_interval = clock_diff(external_clock, u_timer); sync_interval = clock_diff(ext_clock_us, now_clock_us);
if (internal_tick <= external_tick) { if (int_clock_tick <= ext_clock_tick) {
counter -= phase_mult(sync_interval); counter -= phase_mult(sync_interval);
} else { } else {
if (counter > sync_interval) { if (counter > sync_interval) {
@ -392,35 +421,54 @@ void uClockClass::handleTimerInt()
} }
} }
} }
// callback to inform about sync24 event
if (onClock96PPQNCallback) { if (onSync24Callback) {
onClock96PPQNCallback(internal_tick); onSync24Callback(int_clock_tick);
}
// reset counter reference
mod24_counter = mod24_ref;
// internal clock tick me! sync24 tick too
++int_clock_tick;
} }
// 16PPQN call and shuffle processing if enabled // sync signals first please...
if (processShuffle() == 0) { if (onSync48Callback) {
if (onClock16PPQNCallback) { if (mod48_counter == 0) {
onClock16PPQNCallback(div16th_counter); onSync48Callback(sync48_tick);
// reset counter reference
mod48_counter = mod48_ref;
// sync48 tick me!
++sync48_tick;
} }
div16th_counter++;
shuffle_shoot_ctrl = false;
} }
// 32PPQN call. does anyone uses it? // PPQNCallback time!
if (mod6_counter == 3 || mod6_counter == 6) { if (onPPQNCallback) {
if (onClock32PPQNCallback) { onPPQNCallback(tick);
onClock32PPQNCallback(div32th_counter); }
// step callback to support 16th old school style sequencers
// with builtin shuffle for this callback only
if (onStepCallback) {
// processShufle make use of mod_step_counter
if (processShuffle()) {
onStepCallback(step_counter);
// going forward to the next step call
++step_counter;
}
// keep track of mod_step_counter
if (mod_step_counter == 0) {
// reset counter reference
mod_step_counter = mod_step_ref;
} }
div32th_counter++;
} }
// tick me! // tick me!
internal_tick++; ++tick;
mod6_counter++; // decrement mod counters
--mod24_counter;
if (mod6_counter == 6) { --mod48_counter;
mod6_counter = 0; --mod_step_counter;
}
} }
// elapsed time support // elapsed time support
@ -429,7 +477,7 @@ uint8_t uClockClass::getNumberOfSeconds(uint32_t time)
if ( time == 0 ) { if ( time == 0 ) {
return time; return time;
} }
return ((_timer - time) / 1000) % SECS_PER_MIN; return ((_millis - time) / 1000) % SECS_PER_MIN;
} }
uint8_t uClockClass::getNumberOfMinutes(uint32_t time) uint8_t uClockClass::getNumberOfMinutes(uint32_t time)
@ -437,7 +485,7 @@ uint8_t uClockClass::getNumberOfMinutes(uint32_t time)
if ( time == 0 ) { if ( time == 0 ) {
return time; return time;
} }
return (((_timer - time) / 1000) / SECS_PER_MIN) % SECS_PER_MIN; return (((_millis - time) / 1000) / SECS_PER_MIN) % SECS_PER_MIN;
} }
uint8_t uClockClass::getNumberOfHours(uint32_t time) uint8_t uClockClass::getNumberOfHours(uint32_t time)
@ -445,7 +493,7 @@ uint8_t uClockClass::getNumberOfHours(uint32_t time)
if ( time == 0 ) { if ( time == 0 ) {
return time; return time;
} }
return (((_timer - time) / 1000) % SECS_PER_DAY) / SECS_PER_HOUR; return (((_millis - time) / 1000) % SECS_PER_DAY) / SECS_PER_HOUR;
} }
uint8_t uClockClass::getNumberOfDays(uint32_t time) uint8_t uClockClass::getNumberOfDays(uint32_t time)
@ -453,12 +501,12 @@ uint8_t uClockClass::getNumberOfDays(uint32_t time)
if ( time == 0 ) { if ( time == 0 ) {
return time; return time;
} }
return ((_timer - time) / 1000) / SECS_PER_DAY; return ((_millis - time) / 1000) / SECS_PER_DAY;
} }
uint32_t uClockClass::getNowTimer() uint32_t uClockClass::getNowTimer()
{ {
return _timer; return _millis;
} }
uint32_t uClockClass::getPlayTime() uint32_t uClockClass::getPlayTime()
@ -470,11 +518,10 @@ uint32_t uClockClass::getPlayTime()
umodular::clock::uClockClass uClock; umodular::clock::uClockClass uClock;
volatile uint32_t _timer = 0; volatile uint32_t _millis = 0;
// //
// TIMER INTERRUPT HANDLER // TIMER HANDLER
//
// //
#if defined(ARDUINO_ARCH_AVR) #if defined(ARDUINO_ARCH_AVR)
ISR(TIMER1_COMPA_vect) ISR(TIMER1_COMPA_vect)
@ -483,7 +530,7 @@ void uClockHandler()
#endif #endif
{ {
// global timer counter // global timer counter
_timer = millis(); _millis = millis();
if (uClock.state == uClock.STARTED) { if (uClock.state == uClock.STARTED) {
uClock.handleTimerInt(); uClock.handleTimerInt();

151
src/uClock.h
Unescape View File

@ -2,10 +2,10 @@
* @file uClock.h * @file uClock.h
* Project BPM clock generator for Arduino * Project BPM clock generator for Arduino
* @brief A Library to implement BPM clock tick calls using hardware interruption. Supported and tested on AVR boards(ATmega168/328, ATmega16u4/32u4 and ATmega2560) and ARM boards(Teensy, Seedstudio XIAO M0 and ESP32) * @brief A Library to implement BPM clock tick calls using hardware interruption. Supported and tested on AVR boards(ATmega168/328, ATmega16u4/32u4 and ATmega2560) and ARM boards(Teensy, Seedstudio XIAO M0 and ESP32)
* @version 1.5.1 * @version 2.0.0
* @author Romulo Silva * @author Romulo Silva
* @date 10/06/2017 * @date 10/06/2017
* @license MIT - (c) 2022 - Romulo Silva - contact@midilab.co * @license MIT - (c) 2024 - Romulo Silva - contact@midilab.co
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -34,9 +34,18 @@
namespace umodular { namespace clock { namespace umodular { namespace clock {
// min: 2 step, max: 16 steps // for extended steps in memory style and make use of 96ppqn for record propurse we can
// adjust the size of you template if more than 16 needed // keep array[step] memory layout and add new information about note possition to be check for the entire ppqn pulse
// step adjust goes min: -5, max: 5 // example: for a whole 24 pulses we only check array[step].offset that can vary from 0 to 24(ppqn/4)
// time/tick notation and representation notes:
// one quarter note == 4 steps in 16th notes step sequencer style
// PPQN / 4 = pulses in between steps(from step sequencer perspective, a quarter note have 4 steps)
// 24 PPQN (6 pulses per step)
// 48 PPQN (12 pulses per step)
// 96 PPQN (24 pulses per step)
// min: -(ppqn/4)-1 step, max: (ppqn/4)-1 steps
// adjust the size of you template if more than 16 shuffle step info needed
#define MAX_SHUFFLE_TEMPLATE_SIZE 16 #define MAX_SHUFFLE_TEMPLATE_SIZE 16
typedef struct { typedef struct {
bool active = false; bool active = false;
@ -61,85 +70,59 @@ typedef struct {
#define SECS_PER_DAY (SECS_PER_HOUR * 24L) #define SECS_PER_DAY (SECS_PER_HOUR * 24L)
class uClockClass { class uClockClass {
private:
float inline freqToBpm(uint32_t freq);
// shuffle
int8_t inline processShuffle();
void (*onClock96PPQNCallback)(uint32_t tick);
void (*onClock32PPQNCallback)(uint32_t tick);
void (*onClock16PPQNCallback)(uint32_t tick);
void (*onClockStartCallback)();
void (*onClockStopCallback)();
// internal clock control
uint32_t internal_tick;
uint32_t div32th_counter;
uint32_t div16th_counter;
uint8_t mod6_counter;
// external clock control
volatile uint32_t external_clock;
volatile uint32_t external_tick;
volatile uint32_t indiv32th_counter;
volatile uint32_t indiv16th_counter;
volatile uint8_t inmod6_counter;
volatile uint32_t interval;
uint32_t last_interval;
uint32_t sync_interval;
float tempo;
uint32_t start_timer;
uint8_t mode;
volatile uint32_t ext_interval_buffer[EXT_INTERVAL_BUFFER_SIZE];
uint16_t ext_interval_idx;
// shuffle implementation that applies to 16PPQN callback
volatile SHUFFLE_TEMPLATE shuffle;
bool shuffle_shoot_ctrl = true;
volatile int8_t shuffle_length_ctrl = 0;
public: public:
enum SyncMode {
enum {
INTERNAL_CLOCK = 0, INTERNAL_CLOCK = 0,
EXTERNAL_CLOCK EXTERNAL_CLOCK
}; };
enum { enum ClockState {
PAUSED = 0, PAUSED = 0,
STARTING, STARTING,
STARTED STARTED
}; };
enum PPQNResolution {
PPQN_24 = 24,
PPQN_48 = 48,
PPQN_96 = 96,
PPQN_384 = 384,
PPQN_480 = 480,
PPQN_960 = 960
};
uint8_t state; uint8_t state;
uClockClass(); uClockClass();
void setClock96PPQNOutput(void (*callback)(uint32_t tick)) { void setOnPPQN(void (*callback)(uint32_t tick)) {
onClock96PPQNCallback = callback; onPPQNCallback = callback;
} }
void setClock32PPQNOutput(void (*callback)(uint32_t tick)) { void setOnStep(void (*callback)(uint32_t step)) {
onClock32PPQNCallback = callback; onStepCallback = callback;
} }
void setClock16PPQNOutput(void (*callback)(uint32_t tick)) { void setOnSync24(void (*callback)(uint32_t tick)) {
onClock16PPQNCallback = callback; onSync24Callback = callback;
} }
void setOnClockStartOutput(void (*callback)()) { void setOnSync48(void (*callback)(uint32_t tick)) {
onSync48Callback = callback;
}
void setOnClockStart(void (*callback)()) {
onClockStartCallback = callback; onClockStartCallback = callback;
} }
void setOnClockStopOutput(void (*callback)()) { void setOnClockStop(void (*callback)()) {
onClockStopCallback = callback; onClockStopCallback = callback;
} }
void init(); void init();
void setPPQN(PPQNResolution resolution);
void handleTimerInt(); void handleTimerInt();
void handleExternalClock(); void handleExternalClock();
void resetCounters(); void resetCounters();
@ -152,7 +135,7 @@ public:
float getTempo(); float getTempo();
// external timming control // external timming control
void setMode(uint8_t tempo_mode); void setMode(SyncMode tempo_mode);
uint8_t getMode(); uint8_t getMode();
void clockMe(); void clockMe();
@ -161,7 +144,7 @@ public:
bool isShuffled(); bool isShuffled();
void setShuffleSize(uint8_t size); void setShuffleSize(uint8_t size);
void setShuffleData(uint8_t step, int8_t tick); void setShuffleData(uint8_t step, int8_t tick);
void setShuffleTemplate(int8_t * shuff); void setShuffleTemplate(int8_t * shuff, uint8_t size);
// use this to know how many positive or negative ticks to add to current note length // use this to know how many positive or negative ticks to add to current note length
int8_t getShuffleLength(); int8_t getShuffleLength();
@ -175,6 +158,55 @@ public:
uint8_t getNumberOfDays(uint32_t time); uint8_t getNumberOfDays(uint32_t time);
uint32_t getNowTimer(); uint32_t getNowTimer();
uint32_t getPlayTime(); uint32_t getPlayTime();
uint32_t bpmToMicroSeconds(float bpm);
private:
float inline freqToBpm(uint32_t freq);
// shuffle
bool inline processShuffle();
void (*onPPQNCallback)(uint32_t tick);
void (*onStepCallback)(uint32_t step);
void (*onSync24Callback)(uint32_t tick);
void (*onSync48Callback)(uint32_t tick);
void (*onClockStartCallback)();
void (*onClockStopCallback)();
// internal clock control
// uint16_t ppqn;
PPQNResolution ppqn = PPQN_96;
uint32_t tick;
uint32_t int_clock_tick;
uint32_t sync48_tick;
uint8_t mod24_counter;
uint8_t mod24_ref;
uint8_t mod48_counter;
uint8_t mod48_ref;
uint8_t mod_step_counter;
uint8_t mod_step_ref;
uint32_t step_counter; // should we go uint16_t?
// external clock control
volatile uint32_t ext_clock_us;
volatile uint32_t ext_clock_tick;
volatile uint32_t ext_interval;
uint32_t last_interval;
uint32_t sync_interval;
float tempo;
uint32_t start_timer;
SyncMode mode;
volatile uint32_t ext_interval_buffer[EXT_INTERVAL_BUFFER_SIZE];
uint16_t ext_interval_idx;
// shuffle implementation
volatile SHUFFLE_TEMPLATE shuffle;
int8_t last_shff = 0;
bool shuffle_shoot_ctrl = true;
volatile int8_t shuffle_length_ctrl = 0;
}; };
} } // end namespace umodular::clock } } // end namespace umodular::clock
@ -182,8 +214,7 @@ public:
extern umodular::clock::uClockClass uClock; extern umodular::clock::uClockClass uClock;
extern "C" { extern "C" {
extern volatile uint16_t _clock; extern volatile uint32_t _millis;
extern volatile uint32_t _timer;
} }
#endif /* __U_CLOCK_H__ */ #endif /* __U_CLOCK_H__ */

Write Preview
Loading…
Cancel
Save