remove last feature - different resolutions. Added setSlaveDrift for slave clock. update and test examples. code revised

pull/7/head 0.10.2
midilab 4 years ago
parent cdda641ccc
commit ed2dcef683
  1. 17
      examples/LeonardoUsbSlaveMidiClockMonitor/LeonardoUsbSlaveMidiClockMonitor.ino
  2. 2
      examples/TeensyUsbMasterMidiClock/TeensyUsbMasterMidiClock.ino
  3. 2
      examples/TeensyUsbSlaveMidiClock/TeensyUsbSlaveMidiClock.ino
  4. 2
      examples/TeensyUsbSlaveMidiClockMonitor/TeensyUsbSlaveMidiClockMonitor.ino
  5. 2
      library.properties
  6. 256
      src/uClock.cpp
  7. 48
      src/uClock.h

@ -32,6 +32,7 @@ char bpm_str[4];
float bpm = 126.0;
uint8_t bpm_blink_timer = 1;
uint8_t clock_state = 1;
uint8_t clock_mode = 0;
void handle_bpm_led(uint32_t * tick)
{
@ -102,15 +103,15 @@ void setup() {
//
// uClock Setup
//
// fine tunning adjstments for you clock slaves/host setDrift(internal, external)
uClock.setDrift(10, 2);
// Drift for arudino leonardo over USB as MIDI HID
uClock.setSlaveDrift(10);
uClock.init();
uClock.setClock96PPQNOutput(ClockOut96PPQN);
// For MIDI Sync Start and Stop
uClock.setOnClockStartOutput(onClockStart);
uClock.setOnClockStopOutput(onClockStop);
uClock.setMode(uClock.EXTERNAL_CLOCK);
//uClock.setTempo(126.5);
//uClock.setTempo(136.5);
//uClock.start();
}
@ -133,7 +134,7 @@ void printBpm(float _bpm, uint8_t col, uint8_t line) {
}
void loop() {
MIDI.read();
while(MIDI.read()) {}
// DO NOT ADD MORE PROCESS HERE AT THE COST OF LOSING CLOCK SYNC
// Since arduino make use of Serial RX interruption we need to
// read Serial as fast as we can on the loop
@ -149,4 +150,12 @@ void loop() {
u8x8->drawUTF8(0, 7, "stoped ");
}
}
if (clock_mode != uClock.getMode()) {
clock_mode = uClock.getMode();
if (clock_mode == uClock.EXTERNAL_CLOCK) {
u8x8->drawUTF8(10, 0, "slave ");
} else {
u8x8->drawUTF8(10, 0, "master");
}
}
}

@ -56,7 +56,7 @@ void setup() {
// Setup our clock system
// drift for USB Teensy
uClock.setDrift(6, 1);
uClock.setDrift(1);
// Inits the clock
uClock.init();
// Set the callback function for the clock output to send MIDI Sync message.

@ -77,7 +77,7 @@ void setup() {
// Setup our clock system
// drift for USB Teensy
uClock.setDrift(6, 1);
uClock.setDrift(1);
// Inits the clock
uClock.init();
// Set the callback function for the clock output to send MIDI Sync message.

@ -112,7 +112,7 @@ void setup() {
//
// Setup our clock system
// drift for USB Teensy
uClock.setDrift(6, 1);
uClock.setDrift(1);
uClock.init();
uClock.setClock96PPQNOutput(ClockOut96PPQN);
// For MIDI Sync Start and Stop

@ -1,5 +1,5 @@
name=uClock
version=0.10.0
version=0.10.2
author=Romulo Silva <contact@midilab.co>, Manuel Odendahl <wesen@ruinwesen.com>
maintainer=Romulo Silva <contact@midilab.co>
sentence=BPM clock generator for Arduino and Teensy boards

@ -3,7 +3,7 @@
* Project BPM clock generator for Arduino
* @brief A Library to implement BPM clock tick calls using hardware timer1 interruption. Tested on ATmega168/328, ATmega16u4/32u4 and ATmega2560.
* Derived work from mididuino MidiClock class. (c) 2008 - 2011 - Manuel Odendahl - wesen@ruinwesen.com
* @version 0.10.0
* @version 0.10.2
* @author Romulo Silva
* @date 08/21/2020
* @license MIT - (c) 2020 - Romulo Silva - contact@midilab.co
@ -36,93 +36,50 @@
#if defined(TEENSYDUINO) && !defined(__AVR_ATmega32U4__)
IntervalTimer _teensyTimer;
void teensyInterrupt();
void workClock(uint32_t freq_resolution)
void workClock()
{
// fallback default frequency (CLOCK_250000HZ) if no requested freq available
uint8_t microseconds = 4;
const bool running = false;
switch(freq_resolution) {
case CLOCK_62500HZ:
microseconds = 16;
break;
case CLOCK_125000HZ:
microseconds = 8;
break;
case CLOCK_250000HZ:
microseconds = 4;
break;
default:
return;
}
if (running) {
_teensyTimer.update(microseconds);
} else {
_teensyTimer.begin(teensyInterrupt, microseconds);
// Set the interrupt priority level, controlling which other interrupts
// this timer is allowed to interrupt. Lower numbers are higher priority,
// with 0 the highest and 255 the lowest. Most other interrupts default to 128.
// As a general guideline, interrupt routines that run longer should be given
// lower priority (higher numerical values).
_teensyTimer.priority(0);
}
_teensyTimer.begin(teensyInterrupt, 16);
// Set the interrupt priority level, controlling which other interrupts
// this timer is allowed to interrupt. Lower numbers are higher priority,
// with 0 the highest and 255 the lowest. Most other interrupts default to 128.
// As a general guideline, interrupt routines that run longer should be given
// lower priority (higher numerical values).
_teensyTimer.priority(0);
}
#else
void workClock(uint32_t freq_resolution)
void workClock()
{
// fallback default frequency (CLOCK_62500HZ) if no requested freq available
uint8_t comparator = 255;
const bool running = false;
switch(freq_resolution) {
case CLOCK_62500HZ:
comparator = 255;
break;
//case CLOCK_125000HZ:
// comparator = 127;
// break;
//case CLOCK_250000HZ:
// comparator = 63;
// break;
default:
return;
}
if (running) {
// update comparator speed of our internal clock system
OCR1A = comparator;
//OCR2A = comparator;
} else {
ATOMIC(
// Timer1
TCCR1A = 0;
TCCR1B = 0;
TCNT1 = 0;
// set the speed of our internal clock system
OCR1A = comparator;
OCR1A = 255;
// turn on CTC mode
TCCR1B |= (1 << WGM12);
// Set CS12, CS11 and CS10 bits for 1 prescaler
TCCR1B |= (0 << CS12) | (0 << CS11) | (1 << CS10);
// enable timer compare interrupt
TIMSK1 |= (1 << OCIE1A);
/*
)
/*
ATOMIC(
// Timer2
TCCR2A = 0;
TCCR2B = 0;
TCNT2 = 0;
// set the speed of our internal clock system
OCR2A = comparator;
OCR2A = 255;
// turn on CTC mode
TCCR2B |= (1 << WGM21);
// Set CS22, CS21 and CS20 bits for 1 prescaler
TCCR2B |= (0 << CS22) | (0 << CS21) | (1 << CS20);
// enable timer compare interrupt
TIMSK2 |= (1 << OCIE2A);
*/
}
)
*/
}
#endif
@ -144,16 +101,10 @@ static inline uint16_t clock_diff(uint16_t old_clock, uint16_t new_clock)
uClockClass::uClockClass()
{
// some tested values
// 1 is good for native 31250bps midi interface
// 4 is good for usb-to-midi hid on leonardo
// (6, 1) is good on teensy lc usb midi
// internal drift is used to calibrate master clock
internal_drift = 1;
// internal drift is used to calibrate slave clock
external_drift = 1;
// drift is used to sligth calibrate with your slave clock
drift = 1;
slave_drift = 0;
tempo = 120;
pll_x = 220;
start_timer = 0;
last_interval = 0;
sync_interval = 0;
@ -162,58 +113,14 @@ uClockClass::uClockClass()
ext_interval_acc = 0;
resetCounters();
onClock96PPQNCallback = NULL;
onClock32PPQNCallback = NULL;
onClock16PPQNCallback = NULL;
onClockStartCallback = NULL;
onClockStopCallback = NULL;
// set initial default clock operate frequency
// to higher one. If you experience problems
// with your sequencer app process try to go lower
// avr at 16mhz suffers from bellow 16us clock
// but lets get teensy running at higher clock!
#if defined(TEENSYDUINO) && !defined(__AVR_ATmega32U4__)
//freq_resolution = CLOCK_62500HZ; // 62500Hz/16us
//freq_resolution = CLOCK_125000HZ; // 125000Hz/8us
freq_resolution = CLOCK_250000HZ; // 250000Hz/4us
#else
freq_resolution = CLOCK_62500HZ; // 62500Hz/16us
//freq_resolution = CLOCK_125000HZ; // 125000Hz/8us
//freq_resolution = CLOCK_250000HZ; // 250000Hz/4us
#endif
// first interval calculus
setTempo(tempo);
}
void uClockClass::init()
{
// init work clock timer interrupt
workClock(freq_resolution);
}
void uClockClass::setResolution(uint32_t hertz)
{
// only registred frequencies!
switch(hertz) {
case CLOCK_62500HZ:
case CLOCK_125000HZ:
case CLOCK_250000HZ:
break;
default:
return;
}
ATOMIC(
freq_resolution = hertz;
setTempo(tempo);
workClock(freq_resolution);
)
}
uint32_t uClockClass::getResolution()
{
return freq_resolution;
// init work clock timer interrupt in Hz
workClock();
}
void uClockClass::start()
@ -266,9 +173,9 @@ void uClockClass::setTempo(float bpm)
tempo = bpm;
ATOMIC(
interval = (freq_resolution / (tempo * 24 / 60)) - internal_drift;
//interval = (uint16_t)((156250.0 / tempo) - internal_drift);
//interval = 62500 / (tempo * 24 / 60) - internal_drift;
//interval = (freq_resolution / (tempo * 24 / 60)) - drift;
//interval = 62500 / (tempo * 24 / 60) - drift;
interval = (uint16_t)((156250.0 / tempo) - drift);
)
}
@ -285,43 +192,50 @@ float uClockClass::getTempo()
}
if (acc != 0) {
// get average interval, because MIDI sync world is a wild place...
tempo = (((float)freq_resolution/24) * 60) / (acc / acc_counter);
//tempo = (((float)freq_resolution/24) * 60) / (float)(acc / acc_counter);
// derivated one time calc value = ( freq_resolution / 24 ) * 60
//tempo = (float)(156250.0 / ((acc / acc_counter)));
tempo = (float)(156250.0 / (acc / acc_counter));
}
}
return tempo;
}
void uClockClass::setDrift(uint8_t internal, uint8_t external)
void uClockClass::setDrift(uint8_t value)
{
ATOMIC(
internal_drift = internal;
external_drift = external == 255 ? internal : external;
)
ATOMIC(drift = value)
// force set tempo to update runtime interval
setTempo(tempo);
}
uint8_t uClockClass::getInternalDrift()
void uClockClass::setSlaveDrift(uint8_t value)
{
return internal_drift;
ATOMIC(slave_drift = value)
}
uint8_t uClockClass::getExternalDrift()
uint8_t uClockClass::getDrift()
{
return external_drift;
return drift;
}
// each interval is 16us
// this method is usefull for debug
uint16_t uClockClass::getInterval()
{
// since this is a debug method
// we are not going to stop interrupt here
// avoiding jitter
// so interval returned here are not always trust data!
return interval;
}
// Main poolling tick call
uint8_t uClockClass::getTick(uint32_t *_tick)
{
ATOMIC(uint32_t last_tick = tick)
if (*_tick != last_tick) {
*_tick = last_tick;
return 1;
}
return 0;
}
void uClockClass::setMode(uint8_t tempo_mode)
{
mode = tempo_mode;
@ -345,12 +259,8 @@ void uClockClass::resetCounters()
{
counter = 0;
last_clock = 0;
div96th_counter = 0;
div32th_counter = 0;
div16th_counter = 0;
mod6_counter = 0;
indiv96th_counter = 0;
inmod6_counter = 0;
tick = 0;
intick = 0;
ext_interval_idx = 0;
}
@ -370,16 +280,10 @@ void uClockClass::handleExternalClock()
{
last_interval = clock_diff(last_clock, _clock);
last_clock = _clock;
indiv96th_counter++;
inmod6_counter++;
if (inmod6_counter == 6) {
inmod6_counter = 0;
}
// slave tick me!
intick++;
switch (state) {
case PAUSED:
break;
@ -388,14 +292,9 @@ void uClockClass::handleExternalClock()
break;
case STARTED:
if (indiv96th_counter == 2) {
interval = last_interval + external_drift;
} else {
interval = ((((uint32_t)interval * (uint32_t)pll_x) + (uint32_t)(256 - pll_x) * (uint32_t)last_interval) >> 8) + external_drift;
}
// accumulate interval incomming ticks data(for a better getTempo stability over bad clocks)
ext_interval_buffer[ext_interval_idx] = interval;
ext_interval_idx = ++ext_interval_idx % EXT_INTERVAL_BUFFER_SIZE;
interval = last_interval + slave_drift;
// accumulate interval incomming ticks data for getTempo() smooth reads on slave mode
ext_interval_buffer[ext_interval_idx++ % EXT_INTERVAL_BUFFER_SIZE] = interval;
break;
}
}
@ -403,41 +302,21 @@ void uClockClass::handleExternalClock()
void uClockClass::handleTimerInt()
{
if (counter == 0) {
counter = interval;
// need a callback?
// please, use the polling method with getTick() instead...
if (onClock96PPQNCallback) {
onClock96PPQNCallback(&div96th_counter);
}
if (mod6_counter == 0) {
if (onClock32PPQNCallback) {
onClock32PPQNCallback(&div32th_counter);
}
if (onClock16PPQNCallback) {
onClock16PPQNCallback(&div16th_counter);
}
div16th_counter++;
div32th_counter++;
onClock96PPQNCallback(&tick);
}
if (mod6_counter == 3) {
if (onClock32PPQNCallback) {
onClock32PPQNCallback(&div32th_counter);
}
div32th_counter++;
}
div96th_counter++;
mod6_counter++;
// tick me!
tick++;
counter = interval;
if (mode == EXTERNAL_CLOCK) {
sync_interval = clock_diff(last_clock, _clock);
if ((div96th_counter < indiv96th_counter) || (div96th_counter > (indiv96th_counter + 1))) {
div96th_counter = indiv96th_counter;
mod6_counter = inmod6_counter;
if ((tick < intick) || (tick > (intick + 1))) {
tick = intick;
}
if (div96th_counter <= indiv96th_counter) {
if (tick <= intick) {
counter -= phase_mult(sync_interval);
} else {
if (counter > sync_interval) {
@ -445,15 +324,9 @@ void uClockClass::handleTimerInt()
}
}
}
if (mod6_counter == 6) {
mod6_counter = 0;
}
} else {
counter--;
}
}
// elapsed time support
@ -514,6 +387,7 @@ volatile uint32_t _timer = 0;
void teensyInterrupt()
#else
ISR(TIMER1_COMPA_vect)
//ISR(TIMER2_COMPA_vect)
#endif
{
// global timer counter

@ -3,7 +3,7 @@
* Project BPM clock generator for Arduino
* @brief A Library to implement BPM clock tick calls using hardware timer1 interruption. Tested on ATmega168/328, ATmega16u4/32u4 and ATmega2560.
* Derived work from mididuino MidiClock class. (c) 2008 - 2011 - Manuel Odendahl - wesen@ruinwesen.com
* @version 0.10.0
* @version 0.10.2
* @author Romulo Silva
* @date 08/21/2020
* @license MIT - (c) 2020 - Romulo Silva - contact@midilab.co
@ -41,10 +41,6 @@
#define SECS_PER_HOUR (3600UL)
#define SECS_PER_DAY (SECS_PER_HOUR * 24L)
#define CLOCK_62500HZ 62500 // 16 microseconds
#define CLOCK_125000HZ 125000 // 8 microseconds
#define CLOCK_250000HZ 250000 // 4 microseconds
#define MIN_BPM 1
#define MAX_BPM 300
@ -53,30 +49,21 @@ namespace umodular { namespace clock {
class uClockClass {
private:
void (*onClock96PPQNCallback)(uint32_t * tick);
void (*onClock32PPQNCallback)(uint32_t * tick);
void (*onClock16PPQNCallback)(uint32_t * tick);
void (*onClockStartCallback)();
void (*onClockStopCallback)();
// expressed in Hertz
uint32_t freq_resolution;
volatile uint8_t inmod6_counter;
volatile uint32_t indiv96th_counter;
volatile uint32_t tick;
volatile uint32_t intick;
volatile uint16_t interval;
volatile uint16_t last_clock;
uint32_t div96th_counter;
uint32_t div32th_counter;
uint32_t div16th_counter;
uint8_t mod6_counter;
uint16_t counter;
uint32_t last_tick;
uint16_t pll_x;
uint8_t internal_drift;
uint8_t external_drift;
uint8_t drift;
uint8_t slave_drift;
float tempo;
uint32_t start_timer;
uint8_t mode;
@ -108,15 +95,7 @@ class uClockClass {
void setClock96PPQNOutput(void (*callback)(uint32_t * tick)) {
onClock96PPQNCallback = callback;
}
void setClock32PPQNOutput(void (*callback)(uint32_t * tick)) {
onClock32PPQNCallback = callback;
}
void setClock16PPQNOutput(void (*callback)(uint32_t * tick)) {
onClock16PPQNCallback = callback;
}
void setOnClockStartOutput(void (*callback)()) {
onClockStartCallback = callback;
}
@ -136,12 +115,11 @@ class uClockClass {
void pause();
void setTempo(float bpm);
float getTempo();
void setDrift(uint8_t internal, uint8_t external = 255);
uint8_t getInternalDrift();
uint8_t getExternalDrift();
void setResolution(uint32_t hertz);
uint32_t getResolution();
void setDrift(uint8_t value);
uint8_t getDrift();
void setSlaveDrift(uint8_t value);
uint16_t getInterval();
uint8_t getTick(uint32_t *_tick);
// external timming control
void setMode(uint8_t tempo_mode);

Loading…
Cancel
Save