Precisión de tiempo del secuenciador MIDI usando el Arduino

Yo construyo estos secuenciadores de música .

Solo que no es exactamente un secuenciador, es una interfaz física para un secuenciador. El secuenciador es una aplicación que se ejecuta en una computadora portátil a la que se conecta el secuenciador, esto le permite al usuario hacer bucles de batería sobre la marcha. Es bastante divertido, pero requiere una computadora portátil porque el secuenciador no está 'integrado'.

Lo que me encantaría es hacer la secuencia a bordo de mi dispositivo.

Ahora supongamos que sé cómo resolver el cumplimiento de la clase para la conectividad USB MIDI, y también supongamos que puedo descubrir cómo conectar un arduino para enviar notas MIDI desde un puerto DIN de 5 pines. Lo que más me preocupa es la deriva del tempo a lo largo del tiempo debido al tiempo inconsistente en cantidades de minutos en cada ejecución del ciclo de eventos.

Algunas cosas que sé:

1. No debe confiar en delay()controlar el bucle de tempo. La demora detiene toda operación del firmware, y eso no puede funcionar porque necesito sondear la interfaz física del usuario para ver los cambios mientras se ejecuta la secuencia.

2. Los cálculos basados ​​en millis()son mejores porque el firmware puede continuar funcionando y actuar cuando ha transcurrido un cierto recuento.

3. Aunque ninguno de mis controles físicos está activando rutinas de interrupción, algunas operaciones pueden retrasar la loop()ejecución de la unidad principal . Si diseño una función que espera la entrada del usuario, eso obviamente puede causar un problema de perder una "fecha límite" para actuar si la millis()cuenta ha terminado. Sé que este problema es de mi propio diseño ...

Preguntas:

A. ¿Es el arduino basado en AVR un microcontrolador apropiado para sondear una interfaz de usuario y ejecutar un ciclo de sincronización de misión crítica? Sé que ahora hay un Arduino basado en ARM que es mucho más rápido. ¿Teensy 3.0 sería una mejor alternativa? Ambas son placas de 3.3V, así que ese es otro conjunto de problemas con los que trabajar ... pero lo ignoraré por ahora.

B. ¿Debería dividir la tarea en dos microprocesadores? Uno para manejar el sondeo y actualizar la interfaz de usuario y otro para el ciclo de sincronización de misión crítica.

C. ¿Algo más?

Mi objetivo principal es no tener que usar una computadora en absoluto. También quiero calcular el swing, pero en este caso, el swing no significa nada si no tengo un tempo bloqueado y preciso. ¡Gracias por su consejo!

Las interrupciones son su amigo para las tareas delicadas de tiempo, pero solo si coloca los aspectos críticos de tiempo en la interrupción, y no hay otras interrupciones que tengan mayor prioridad. Los microcontroladores en el Arduino "basado en AVR" (por ejemplo, el ATmega328P) tienen prioridades de interrupción fijas como se detalla en la página 58ff de la hoja de datos . Entonces, si usó TIMER2 COMPA como su interrupción de tiempo crítica y ninguna otra interrupción, debería estar bien (ya que tiene la máxima prioridad). Si también desea usar interrupciones de menor prioridad, debe asegurarse de que todas ellas vuelvan a habilitar las interrupciones globales al ingresar a su rutina de servicio de interrupciones:

Cuando ocurre una interrupción, el bit I de habilitación de interrupción global se borra y todas las interrupciones se deshabilitan. El software del usuario puede escribir la lógica uno en el bit I para habilitar las interrupciones anidadas. Todas las interrupciones habilitadas pueden interrumpir la rutina de interrupción actual.

(p. 14 de la hoja de datos )

Esto es ligeramente diferente en Arduinos basados ​​en ARM, ya que su núcleo Cortex-M3 tiene un "Controlador de interrupción vectorial anidado", donde las prioridades no son fijas (se pueden configurar en el software), y el manejo de interrupciones anidadas es la norma. Entonces, para cronometrar aplicaciones críticas, el Arduino basado en ARM le daría más flexibilidad. Sin embargo, no creo que sea realmente necesario para su aplicación.

La pregunta más importante es qué tan fácil se pueden implementar estas cosas con las bibliotecas Arduino. Para obtener el mejor rendimiento, probablemente tendrá que codificar fuera de las bibliotecas hasta cierto punto, al menos para los bits críticos de tiempo, es decir, evitar cosas como delay () o millis () por completo.

Si necesita o no dividirse depende de cuánto procesamiento tenga intención de hacer. Nuevamente, salir de las bibliotecas puede potencialmente brindarle un mejor rendimiento.

Esto, con la programación adecuada, definitivamente se puede hacer en un ATmega328P (dependiendo en cierta medida de la complejidad del loop de batería. Supongo que ~ <50 eventos de batería en el loop. ¿Es razonable?).

Tenga en cuenta que dije ATmega328P , no necesariamente un Arduino .

El entorno Arduino tiene muchas cosas predeterminadas que se ejecutan en segundo plano, lo que hace que la programación extremadamente determinista (ya que necesitará algo crítico para el tiempo) sea un desafío.

La verdadera pregunta que debe hacerse aquí es: ¿qué tan interesado está en la programación y qué tan interesado está en desarrollar un instrumento?

Si bien estoy bastante seguro de que es posible hacer todo lo que desee en un solo ATmega (bucle de batería, múltiples entradas analógicas, LCD, botones, interfaz MIDI), la verdadera pregunta es ¿cuánto trabajo será exprimir todo? Nuevamente, ¿desea aprender a optimizar el código MCU incorporado o construir instrumentos? Es muy fácil sólo tiene que ir a un rápido MCU si es necesario, pero es necesario para determinar el rendimiento MCU lo que necesita ahora , por lo que seis meses de trabajo en, no se dan cuenta que no puedes bastante conseguir que todo funcione tan rápido como necesitar.

Si yo fuera usted, lo primero que haría es hacerlo funcionar sin cosas de arduino (básicamente, trátelo como un ATmega en bruto y use AVR studio o similar). Luego, puede analizar de manera mucho más eficaz qué tipo de rendimiento necesita y si ATmega puede administrarlo.

Una vez que esté libre de las cosas de arduino, es mucho más libre de usar diferentes MCU (generalmente son más similares que diferentes. Si puede descubrir uno de su documentación, probablemente pueda hacer lo mismo para los demás).

He estado trabajando con los dispositivos ATxmega MUCHO recientemente, y son realmente agradables. Obtiene tres prioridades de interrupción, que facilitan mucho la gestión de cosas críticas. También son muy agradables para trabajar (¡diseños periféricos sanos! ¡Convenientes estructuras de puertos! Etc ...).

También están los dispositivos LPC de NXP, que están basados ​​en ARM, así como algunos de los dispositivos ARM de Atmel (como se usan en Arduino Due), o las MCU STM32 de ST. Cualquiera de estos tendrá un rendimiento significativamente mayor que un ATmega, o incluso un ATxmega.

La desventaja principal de un procesador más grande y potente es el precio, pero a menos que esté produciendo miles de esas unidades, los costos de ensamblaje y fabricación por unidad excederán en gran medida la diferencia de costo (que probablemente sea solo unos pocos dólares) ) que es básicamente irrelevante.

Necesitaba leer sobre los temporizadores antes de comenzar a pensar en la precisión del tiempo (también construir un secuenciador midi con un arduino, aunque está garantizado que se verá menos genial que esos ^^). Esta serie de artículos ha sido la más informativa:

http://maxembedded.com/category/microcontrollers-2/atmel-avr/avr-timers-atmel-avr/

En este momento creo que mi solución para obtener el tiempo preciso será.

A. Use el AVR arduino

B. Mantenga la tarea en un microprocesador

C. Use sabiamente preescaladores, temporizadores e interrupciones para obtener la precisión que se necesita.

ACTUALIZAR

Utilizando el tutorial midi básico para Arduino y después de mirar este artículo sobre temporizadores y preescaladores, se me ocurrió el siguiente código. El código utiliza el modo timer1 y CTC para reproducir una nota midi cada cuarto de segundo y una nota cada cuarto de segundo (que debería ser exactamente 120 lpm). Lamentablemente, esto sigue llegando más lento que 120bpm, aunque esto es lo más cerca que he llegado ...

// Includes
#include <avr/io.h>
#include <avr/interrupt.h>

int last_action=0;

void setup()
{
    //  Set MIDI baud rate:
    Serial.begin(31250);

    // initialize Timer1
    cli();          // disable global interrupts
    TCCR1A = 0;     // set entire TCCR1A register to 0
    TCCR1B = 0;     // same for TCCR1B

    // set compare match register to desired timer count:
    OCR1A = 15624;
    // turn on CTC mode:
    TCCR1B |= (1 << WGM12);
    // Set CS12 bits for 256 prescaler:
    TCCR1B |= (1 << CS12);
    // enable timer compare interrupt:
    TIMSK1 |= (1 << OCIE1A);
    // enable global interrupts:
    sei();
}

void loop()
{
    // do some crazy stuff while my midi notes are playing
}

ISR(TIMER1_COMPA_vect)
{
  // Turn notes on
  if (last_action == 0) {
    send_note(0x90, 60, 0x45);
    last_action = 1;

  // Turn notes off
  } else {
    send_note(0x90, 60, 0x00);
    last_action = 0;
  }
}

//  plays a MIDI note
void send_note(int cmd, int pitch, int velocity) {
  Serial.write(cmd);
  Serial.write(pitch);
  Serial.write(velocity);
}

ACTUALIZAR

He estado luchando con esto durante ~ 24 horas y finalmente obtuve algunas respuestas del foro. Creo que el código que usé arriba ^^ es bastante bueno. Usando el ISR, usando el modo CTC y los preescaladores, etc. Después de llegar al foro , creo que la solución es menos acerca de lograr precisión en el secuenciador midi, sino de conectar toda mi configuración de hardware (mis sintetizadores y samplers) a la misma reloj midi, ya sea que el reloj provenga o no del Arduino.

Dependiendo de cuán gradualmente desee hacer la transición de una computadora atada a un sistema basado en µC, puede considerar colocar una Raspberry Pi dentro de esa caja ($ 25-35 al por menor ). De esa manera, puede tener una computadora basada en Linux completa (aunque de baja potencia) con puertos USB y pines GPIO.