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

remove freertos support(unstable so far) and make interrupted version the default only. update main example

Browse Source
pull/33/head
midilab 7 months ago
parent e41fb3157a
commit 9d8865b024
4 changed files with 84 additions and 233 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. 94
      examples/RP2040ClockBlink/RP2040ClockBlink.ino
  2. 76
      examples/RP2040UsbUartMasterClock/RP2040UsbUartMasterClock.ino
  3. 37
      examples/RP2040UsbUartMasterClock/builtin_led.ino
  4. 110
      src/platforms/rp2040.h

94
examples/RP2040ClockBlink/RP2040ClockBlink.ino
Unescape View File

@ -1,94 +0,0 @@
/* USB MIDI Sync Box - RP2040 example that just blinks LED
*
*
* This example code is in the public domain.
*
*/
//#define LED_BUILTIN PIN_LED_B
#include "Adafruit_TinyUSB.h"
#include <uClock.h>
#define ATOMIC(X) { uint32_t __interrupt_mask = save_and_disable_interrupts(); X; restore_interrupts(__interrupt_mask); }
uint8_t bpm_blink_timer = 1;
void handle_bpm_led(uint32_t tick)
{
// BPM led indicator
if ( !(tick % (96)) || (tick == 1) ) { // first compass step will flash longer
bpm_blink_timer = 8;
digitalWrite(LED_BUILTIN, LOW);
} else if ( !(tick % (24)) ) { // each quarter led on
bpm_blink_timer = 1;
digitalWrite(LED_BUILTIN, LOW);
} else if ( !(tick % bpm_blink_timer) ) { // get led off
digitalWrite(LED_BUILTIN, HIGH);
}
}
// Internal clock handlers
void onSync24Callback(uint32_t tick) {
handle_bpm_led(tick);
}
void onClockStart() {
//MIDI_USB.sendRealTime(midi::Start);
}
void onClockStop() {
//MIDI_USB.sendRealTime(midi::Stop);
}
void setup() {
/*#if defined(ARDUINO_ARCH_MBED) && defined(ARDUINO_ARCH_RP2040)
// Manual begin() is required on core without built-in support for TinyUSB such as mbed rp2040
TinyUSB_Device_Init(0);
#endif*/
//MIDI_USB.begin(MIDI_CHANNEL_OMNI);
// A led to count bpms
pinMode(LED_BUILTIN, OUTPUT);
/*digitalWrite(LED_BUILTIN, HIGH);
delay(500);
digitalWrite(LED_BUILTIN, LOW);
delay(500);
digitalWrite(LED_BUILTIN, HIGH);
delay(500);
digitalWrite(LED_BUILTIN, LOW);
delay(500);*/
Serial.begin(115200);
/*while (!Serial)
delay(1);*/
// Setup our clock system
// Inits the clock
uClock.init();
// Set the callback function for the clock output to send MIDI Sync message.
uClock.setOnSync24(onSync24Callback);
// Set the callback function for MIDI Start and Stop messages.
uClock.setOnClockStart(onClockStart);
uClock.setOnClockStop(onClockStop);
// Set the clock BPM to 126 BPM
uClock.setTempo(60);
// Starts the clock, tick-tac-tick-tac..
//Serial.println("about to uClock.start()..."); Serial.flush();
uClock.start();
//Serial.println("uClock.start()ed!"); Serial.flush();
}
uint32_t count = 0;
// Do it whatever to interface with Clock.stop(), Clock.start(), Clock.setTempo() and integrate your environment...
void loop() {
//MIDI_USB.read();
//count++;
//if (millis()%1000==0)
// ATOMIC(Serial.println("looped!"));
}

76
examples/RP2040UsbMasterMidiClock/RP2040UsbMasterMidiClock.ino → examples/RP2040UsbUartMasterClock/RP2040UsbUartMasterClock.ino
Unescape View File

@ -1,95 +1,74 @@
/* USB MIDI Sync Box - example that also prints to serial and sends USB midi as well as blinking LED /*
* (usb part still needs testing to make sure it works!) * USB/Uart MIDI Sync Box
* *
* This example code is in the public domain. * This example code is in the public domain.
* *
*/ */
#include <Adafruit_TinyUSB.h> #include <Adafruit_TinyUSB.h>
#include <MIDI.h> #include <MIDI.h>
Adafruit_USBD_MIDI usb_midi;
MIDI_CREATE_INSTANCE(Adafruit_USBD_MIDI, usb_midi, MIDI_USB);
//MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, MIDI);
#include <uClock.h> #include <uClock.h>
#define ATOMIC(X) { uint32_t __interrupt_mask = save_and_disable_interrupts(); X; restore_interrupts(__interrupt_mask); } // Instantiate the MIDI interfaces
//#define LED_BUILTIN PIN_LED_B Adafruit_USBD_MIDI usb_midi;
//#define WAIT_FOR_SERIAL MIDI_CREATE_INSTANCE(Adafruit_USBD_MIDI, usb_midi, MIDI_USB);
#define ENABLE_MULTICORE MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, MIDI);
volatile uint32_t count = 0; // Do your rpi 2040 has a ws2812 RGB LED? set the pin!
// otherwise keep it commented for normal LED_BUILTIN led blinking
#define WS2812_BUILTIN_LED 16
uint8_t bpm_blink_timer = 1; uint8_t bpm_blink_timer = 1;
void handle_bpm_led(uint32_t tick) void handle_bpm_led(uint32_t tick)
{ {
// BPM led indicator // BPM led indicator
if ( !(tick % (96)) || (tick == 1) ) { // first compass step will flash longer if ( !(tick % (96)) || (tick == 1) ) { // first of 4 quarter pulse will flash longer
bpm_blink_timer = 8; bpm_blink_timer = 8;
digitalWrite(LED_BUILTIN, LOW); ledOn();
} else if ( !(tick % (24)) ) { // each quarter led on } else if ( !(tick % (24)) ) { // each quarter led on
bpm_blink_timer = 1; bpm_blink_timer = 1;
digitalWrite(LED_BUILTIN, LOW); ledOn();
} else if ( !(tick % bpm_blink_timer) ) { // get led off } else if ( !(tick % bpm_blink_timer) ) { // get led off
digitalWrite(LED_BUILTIN, HIGH); ledOff();
} }
} }
// Internal clock handlers // Internal clock handlers
void onSync24Callback(uint32_t tick) { void onSync24Callback(uint32_t tick) {
// Send MIDI_CLOCK to external gears // Send MIDI_CLOCK to external gears
MIDI.sendRealTime(midi::Clock);
MIDI_USB.sendRealTime(midi::Clock); MIDI_USB.sendRealTime(midi::Clock);
// blink tempo
handle_bpm_led(tick); handle_bpm_led(tick);
Serial.printf("ticked with %u\n", tick);
} }
void onClockStart() { void onClockStart() {
MIDI.sendRealTime(midi::Start);
MIDI_USB.sendRealTime(midi::Start); MIDI_USB.sendRealTime(midi::Start);
} }
void onClockStop() { void onClockStop() {
MIDI.sendRealTime(midi::Stop);
MIDI_USB.sendRealTime(midi::Stop); MIDI_USB.sendRealTime(midi::Stop);
} }
#ifdef ENABLE_MULTICORE
void setup1() {
}
void loop1() {
if (count%1000==0)
ATOMIC(Serial.println("loop1()!"); Serial.flush());
}
#endif
void setup() { void setup() {
#if defined(ARDUINO_ARCH_MBED) && defined(ARDUINO_ARCH_RP2040) #if defined(ARDUINO_ARCH_MBED) && defined(ARDUINO_ARCH_RP2040)
// Manual begin() is required on core without built-in support for TinyUSB such as mbed rp2040 // Manual begin() is required on core without built-in support for TinyUSB such as mbed rp2040
TinyUSB_Device_Init(0); TinyUSB_Device_Init(0);
#endif #endif
// Initialize USB midi stack
MIDI_USB.begin(MIDI_CHANNEL_OMNI); MIDI_USB.begin(MIDI_CHANNEL_OMNI);
// Initialize UART midi stack
MIDI.begin(MIDI_CHANNEL_OMNI);
// A led to count bpms // Initialize builtin led for clock timer blinking
pinMode(LED_BUILTIN, OUTPUT); initBlinkLed();
Serial.begin(115200);
#ifdef WAIT_FOR_SERIAL
while (!Serial)
delay(1);
#endif
// wait until device mounted
while( !TinyUSBDevice.mounted() ) {
Serial.println("waiting for usb..");
Serial.flush();
delay(1);
}
// Setup our clock system // Setup our clock system
// Inits the clock // Inits the clock
Serial.println("about to uClock.init()..."); Serial.flush();
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.
uClock.setOnSync24(onSync24Callback); uClock.setOnSync24(onSync24Callback);
@ -97,17 +76,14 @@ void setup() {
uClock.setOnClockStart(onClockStart); uClock.setOnClockStart(onClockStart);
uClock.setOnClockStop(onClockStop); uClock.setOnClockStop(onClockStop);
// Set the clock BPM to 126 BPM // Set the clock BPM to 126 BPM
uClock.setTempo(60); uClock.setTempo(126);
// Starts the clock, tick-tac-tick-tac.. // Starts the clock, tick-tac-tick-tac..
Serial.println("about to uClock.start()..."); Serial.flush();
uClock.start(); uClock.start();
ATOMIC(Serial.println("uClock.start()ed!"); Serial.flush();)
} }
// Do it whatever to interface with Clock.stop(), Clock.start(), Clock.setTempo() and integrate your environment... // Do it whatever to interface with Clock.stop(), Clock.start(), Clock.setTempo() and integrate your environment...
void loop() { void loop() {
// handle midi input?
MIDI.read();
MIDI_USB.read(); MIDI_USB.read();
count++;
if (millis()%1000==0)
ATOMIC(Serial.println("loop()!"); Serial.flush(););
} }

37
examples/RP2040UsbUartMasterClock/builtin_led.ino
Unescape View File

@ -0,0 +1,37 @@
#if defined(WS2812_BUILTIN_LED)
#include <Adafruit_NeoPixel.h>
#define NUMPIXELS 1
Adafruit_NeoPixel pixels(NUMPIXELS, WS2812_BUILTIN_LED, NEO_GRB + NEO_KHZ800);
#endif
// check the pinage for BUILTIN LED of your model in case LED_BUILTIN wont ligth up
// this is valid only if you're not using rgb version ws2812 (WS2812_BUILTIN_LED)
//#define LED_BUILTIN PIN_LED_B
void initBlinkLed() {
#if defined(WS2812_BUILTIN_LED)
// use adafruit neo pixel
pixels.begin();
#else
// normal led pin
pinMode(LED_BUILTIN, OUTPUT);
#endif
}
void ledOn() {
#if defined(WS2812_BUILTIN_LED)
pixels.setPixelColor(0, pixels.Color(0, 0, 20));
pixels.show(); // turn the LED on (HIGH is the voltage level)
#else
digitalWrite(LED_BUILTIN, LOW);
#endif
}
void ledOff() {
#if defined(WS2812_BUILTIN_LED)
pixels.setPixelColor(0, pixels.Color(0, 0, 0));
pixels.show();
#else
digitalWrite(LED_BUILTIN, HIGH);
#endif
}

110
src/platforms/rp2040.h
Unescape View File

@ -1,98 +1,30 @@
#include <Arduino.h> #include <Arduino.h>
#include "pico/sync.h" #include "pico/sync.h"
// todo: make this a build flag, so user can choose which method to use? // RPi-specific timer
#define MULTICORE struct repeating_timer timer;
#ifdef MULTICORE #define ATOMIC(X) { uint32_t __interrupt_mask = save_and_disable_interrupts(); X; restore_interrupts(__interrupt_mask); }
// use interrupt version -- works for 2 cores ie can run loop1() and loop() simultaneously as well as the clock callback?
// RPi-specific timer // forward declaration of uClockHandler
struct repeating_timer timer; void uClockHandler();
#define ATOMIC(X) { uint32_t __interrupt_mask = save_and_disable_interrupts(); X; restore_interrupts(__interrupt_mask); } // ISR handler -- called when tick happens
bool handlerISR(repeating_timer *timer)
{
uClockHandler();
// forward declaration of uClockHandler return true;
void uClockHandler(); }
// ISR handler -- called when tick happens void initTimer(uint32_t init_clock) {
bool handlerISR(repeating_timer *timer) // set up RPi interrupt timer
{ // todo: actually should be -init_clock so that timer is set to start init_clock us after last tick, instead of init_clock us after finished processing last tick!
uClockHandler(); add_repeating_timer_us(init_clock, &handlerISR, NULL, &timer);
}
return true; void setTimer(uint32_t us_interval) {
} cancel_repeating_timer(&timer);
// todo: actually should be -us_interval so that timer is set to start init_clock us after last tick, instead of init_clock us after finished processing last tick!
void initTimer(uint32_t init_clock) { add_repeating_timer_us(us_interval, &handlerISR, NULL, &timer);
// set up RPi interrupt timer }
// todo: actually should be -init_clock so that timer is set to start init_clock us after last tick, instead of init_clock us after finished processing last tick!
add_repeating_timer_us(init_clock, &handlerISR, NULL, &timer);
}
void setTimer(uint32_t us_interval) {
cancel_repeating_timer(&timer);
// todo: actually should be -us_interval so that timer is set to start init_clock us after last tick, instead of init_clock us after finished processing last tick!
add_repeating_timer_us(us_interval, &handlerISR, NULL, &timer);
}
#else
// use FreeRTOS scheduling/mutex version -- doesn't work (task starts but does not run) if using loop1() ie core 2
#include "FreeRTOS.h"
#include <task.h>
#include <semphr.h>
// RPi-specific timer
struct repeating_timer timer;
// FreeRTOS main clock task size in bytes
#define CLOCK_STACK_SIZE 5*1024 // adjust for your needs, a sequencer with heavy serial handling should be large in size
TaskHandle_t taskHandle;
// mutex to protect the shared resource
SemaphoreHandle_t _mutex;
// mutex control for task
#define ATOMIC(X) xSemaphoreTake(_mutex, portMAX_DELAY); X; xSemaphoreGive(_mutex);
// forward declaration of uClockHandler
void uClockHandler();
// ISR handler -- called when tick happens
bool handlerISR(repeating_timer *timer)
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
// Send a notification to task1
vTaskNotifyGiveFromISR(taskHandle, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
return true;
}
// task for user clock process
void clockTask(void *pvParameters)
{
while (1) {
// wait for a notification from ISR
ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
uClockHandler();
}
}
void initTimer(uint32_t init_clock)
{
// initialize the mutex for shared resource access
_mutex = xSemaphoreCreateMutex();
// create the clockTask
xTaskCreate(clockTask, "clockTask", CLOCK_STACK_SIZE, NULL, 1, &taskHandle);
// set up RPi interrupt timer
// todo: actually should be -init_clock so that timer is set to start init_clock us after last tick, instead of init_clock us after finished processing last tick!
add_repeating_timer_us(init_clock, &handlerISR, NULL, &timer);
}
void setTimer(uint32_t us_interval) {
cancel_repeating_timer(&timer);
// todo: actually should be -us_interval so that timer is set to start init_clock us after last tick, instead of init_clock us after finished processing last tick!
add_repeating_timer_us(us_interval, &handlerISR, NULL, &timer);
}
#endif
Write Preview
Loading…
Cancel
Save