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

examples/LeonardoUsbSlaveMidiClockMonitor/LeonardoUsbSlaveMidiClockMonitor.ino

@@ -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)
+  // Drift for arudino leonardo over USB as MIDI HID
-  uClock.setDrift(10, 2);
+  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"); 
+    }
+  }
 }

examples/TeensyUsbMasterMidiClock/TeensyUsbMasterMidiClock.ino

@@ -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.

examples/TeensyUsbSlaveMidiClock/TeensyUsbSlaveMidiClock.ino

@@ -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.

examples/TeensyUsbSlaveMidiClockMonitor/TeensyUsbSlaveMidiClockMonitor.ino

@@ -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

library.properties

@@ -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

src/uClock.cpp

@@ -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
+	_teensyTimer.begin(teensyInterrupt, 16);
-	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);
-	}
 
 }
 #else
-void workClock(uint32_t freq_resolution)
+void workClock()
 {
-	// fallback default frequency (CLOCK_62500HZ) if no requested freq available
+	ATOMIC(
-	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 {
 		// 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
+	// drift is used to sligth calibrate with your slave clock
-	// 1 is good for native 31250bps midi interface
+	drift = 1;
-	// 4 is good for usb-to-midi hid on leonardo
+	slave_drift = 0;
-	// (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;
 	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
+	// init work clock timer interrupt in Hz
-	workClock(freq_resolution);
+	workClock();
-}
-
-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;
 }
 
 void uClockClass::start() 
@@ -266,9 +173,9 @@ void uClockClass::setTempo(float bpm)
 	tempo = bpm;
 
 	ATOMIC(
-		interval = (freq_resolution / (tempo * 24 / 60)) - internal_drift;
+		//interval = (freq_resolution / (tempo * 24 / 60)) - drift;
-		//interval = (uint16_t)((156250.0 / tempo) - internal_drift);
+		//interval = 62500 / (tempo * 24 / 60) - drift;
-		//interval = 62500 / (tempo * 24 / 60) - internal_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(
+	ATOMIC(drift = value)
-		internal_drift = internal;
-		external_drift = external == 255 ? internal : external;
-	)
 	// 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;
+	tick = 0;
-	div32th_counter = 0;
+	intick = 0;
-	div16th_counter = 0;
-	mod6_counter = 0;
-	indiv96th_counter = 0;
-	inmod6_counter = 0;
 	ext_interval_idx = 0;
 }
 
@@ -370,16 +280,10 @@ void uClockClass::handleExternalClock()
 {
 	last_interval = clock_diff(last_clock, _clock);
 	last_clock = _clock;
-
+	// slave tick me!
-	indiv96th_counter++;
+	intick++;
-	inmod6_counter++;
-
-	if (inmod6_counter == 6) {
-		inmod6_counter = 0;
-	}
 
 	switch (state) {
-
 		case PAUSED:
 			break;
 
@@ -388,14 +292,9 @@ void uClockClass::handleExternalClock()
 			break;
 
 		case STARTED:
-			if (indiv96th_counter == 2) {
+			interval = last_interval + slave_drift;
-				interval = last_interval + external_drift;
+			// accumulate interval incomming ticks data for getTempo() smooth reads on slave mode
-			} else {
+			ext_interval_buffer[ext_interval_idx++ % EXT_INTERVAL_BUFFER_SIZE] = interval;
-				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;
 			break;
 	}
 }
@@ -403,41 +302,21 @@ void uClockClass::handleExternalClock()
 void uClockClass::handleTimerInt()  
 {
 	if (counter == 0) {
-		
+		// need a callback?
-		counter = interval;
+		// please, use the polling method with getTick() instead...
-
 		if (onClock96PPQNCallback) {
-			onClock96PPQNCallback(&div96th_counter);
+			onClock96PPQNCallback(&tick);
-		}
-		
-		if (mod6_counter == 0) {
-			if (onClock32PPQNCallback) {
-				onClock32PPQNCallback(&div32th_counter);
-			}			
-			if (onClock16PPQNCallback) {
-				onClock16PPQNCallback(&div16th_counter);
-			}
-			div16th_counter++;
-			div32th_counter++;
-		}
-
-		if (mod6_counter == 3) {
-			if (onClock32PPQNCallback) {
-				onClock32PPQNCallback(&div32th_counter);
-			}
-			div32th_counter++;
 		}
 
-		div96th_counter++;
+		// tick me!
-		mod6_counter++;
+		tick++;
-	
+		counter = interval;
 		if (mode == EXTERNAL_CLOCK) {
 			sync_interval = clock_diff(last_clock, _clock);
-			if ((div96th_counter < indiv96th_counter) || (div96th_counter > (indiv96th_counter + 1))) {
+			if ((tick < intick) || (tick > (intick + 1))) {
-				div96th_counter = indiv96th_counter;
+				tick = intick;
-				mod6_counter = inmod6_counter;
 			}
-			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

src/uClock.h

@@ -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
 
@@ -55,28 +51,19 @@ 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
+		volatile uint32_t tick;
-		uint32_t freq_resolution;
+		volatile uint32_t intick;
-
-		volatile uint8_t inmod6_counter;
-		volatile uint32_t indiv96th_counter;
 		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 drift;
-		uint8_t internal_drift;
+		uint8_t slave_drift;
-		uint8_t external_drift;
 		float tempo;
 		uint32_t start_timer;
 		uint8_t mode;
@@ -109,14 +96,6 @@ class uClockClass {
 			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);
+		void setDrift(uint8_t value);
-		uint8_t getInternalDrift();
+		uint8_t getDrift();
-		uint8_t getExternalDrift();
+		void setSlaveDrift(uint8_t value);
-		void setResolution(uint32_t hertz);
-		uint32_t getResolution();
 		uint16_t getInterval();
+		uint8_t getTick(uint32_t *_tick);
 
 		// external timming control
 		void setMode(uint8_t tempo_mode);