Précision de synchronisation du séquenceur MIDI à l'aide de l'Arduino

Je construis ces séquenceurs musicaux .

Seulement ce n'est pas exactement un séquenceur, c'est une interface physique pour un séquenceur. Le séquenceur est une application qui s'exécute sur un ordinateur portable auquel le séquenceur se connecte, cette chose permet à l'utilisateur de faire des boucles de batterie à la volée. C'est assez amusant, mais cela nécessite un ordinateur portable car le séquenceur n'est pas «embarqué».

Ce que j'aimerais, c'est faire le séquençage à bord de mon appareil.

Supposons maintenant que je sais comment résoudre la conformité de classe pour la connectivité USB MIDI, et supposons également que je peux comprendre comment câbler un arduino pour envoyer des notes MIDI à partir d'un port DIN à 5 broches. Ce qui m'inquiète le plus, c'est la dérive du tempo dans le temps en raison d'un timing incohérent en nombre de minutes à chaque exécution de la boucle d'événement.

Certaines choses que je sais:

1. Vous ne devriez pas vous fier delay()à contrôler la boucle de tempo. Le retard arrête toutes les opérations du micrologiciel, et cela ne peut pas fonctionner car j'ai besoin d'interroger l'interface utilisateur physique pour les modifications pendant l'exécution de la séquence.

2. Les calculs basés sur millis()sont meilleurs car le firmware peut continuer à fonctionner et à agir lorsqu'un certain décompte s'est écoulé.

3. Même si aucun de mes contrôles physiques ne déclenche des routines d'interruption, certaines opérations peuvent retarder l' loop()exécution du principal . Si je conçois une fonction qui attend la saisie de l'utilisateur, cela peut évidemment causer un problème de manque de «délai» pour agir si le millis()nombre est bien dépassé. Je sais que ce problème est de ma propre conception ...

Des questions:

A. L'arduino basé sur AVR est-il un microcontrôleur approprié pour interroger une interface utilisateur et exécuter une boucle de synchronisation critique pour la mission? Je sais qu'il y a maintenant un Arduino basé sur ARM qui est beaucoup plus rapide. Un Teensy 3.0 serait-il une meilleure alternative? Les deux sont des cartes 3,3 V, c'est donc un autre ensemble de problèmes avec lesquels travailler ... mais je l'ignorerai pour l'instant.

B. Dois-je diviser la tâche en deux microprocesseurs? Un pour gérer l'interrogation et la mise à jour de l'interface utilisateur et un pour la boucle de synchronisation critique pour la mission.

c. Autre chose?

Mon objectif principal est de ne pas avoir à utiliser d'ordinateur du tout. Je veux également calculer le swing, mais dans ce cas, le swing ne veut rien dire si je n'ai pas un tempo verrouillé et précis. Merci pour vos conseils!

Les interruptions sont votre ami pour chronométrer les tâches sensibles, mais uniquement si vous mettez les aspects critiques de synchronisation dans l'interruption, et qu'aucune autre interruption ne se produit qui a une priorité plus élevée. Les microcontrôleurs de l'Arduino "basé sur AVR" (par exemple l'ATmega328P) ont des priorités d'interruption fixes, comme détaillé à la page 58ff de la fiche technique . Donc, si vous avez utilisé TIMER2 COMPA comme interruption de synchronisation critique et aucune autre interruption, vous devriez être OK (car il a la priorité la plus élevée). Si vous souhaitez également utiliser des interruptions de priorité inférieure, vous devez vous assurer que toutes réactivent les interruptions globales lors de la saisie de leur routine de service d'interruption:

Lorsqu'une interruption se produit, le bit I d'activation d'interruption globale est effacé et toutes les interruptions sont désactivées. Le logiciel utilisateur peut écrire une logique sur le bit I pour activer les interruptions imbriquées. Toutes les interruptions activées peuvent alors interrompre la routine d'interruption en cours.

(p. 14 de la fiche technique )

Ceci est légèrement différent sur les Arduinos basés sur ARM car leur cœur Cortex-M3 a un "contrôleur d'interruption de vecteur imbriqué", où les priorités ne sont pas fixes (peuvent être définies dans le logiciel), et la gestion des interruptions imbriquées est la norme. Ainsi, pour le chronométrage d'applications critiques, l'Arduino basé sur ARM vous offrirait plus de flexibilité. Cependant, je ne pense pas que ce soit vraiment nécessaire pour votre candidature.

La plus grande question est vraiment de savoir comment ces choses peuvent être implémentées facilement avec les bibliothèques Arduino. Pour obtenir les meilleures performances, vous devrez probablement coder en dehors des bibliothèques dans une certaine mesure, au moins pour les bits critiques de synchronisation, c'est-à-dire éviter des choses comme delay () ou millis ().

La nécessité ou non de fractionner dépend de la quantité de traitement que vous comptez effectuer. Encore une fois, sortir des bibliothèques peut potentiellement vous donner de meilleures performances.

Cela peut, avec la programmation appropriée, se faire très certainement sur un ATmega328P (en fonction quelque peu de la complexité de la boucle de batterie. Je suppose que ~ <50 événements de batterie dans la boucle. Est-ce raisonnable?).

Notez que j'ai dit ATmega328P , pas nécessairement un Arduino .

L'environnement Arduino a beaucoup de choses par défaut en arrière-plan, ce qui rend la programmation extrêmement déterministe (car vous aurez besoin de quelque chose de temporel critique) difficile.

La vraie question que vous devez vous poser ici est à quel point êtes-vous intéressé par la programmation, à quel point êtes-vous intéressé à développer un instrument?

Bien que je sois tout à fait convaincu qu'il est possible de faire tout ce que vous voulez sur une seule ATmega (boucle de batterie, plusieurs entrées analogiques, LCD, boutons, interface MIDI), la vraie question est de savoir combien de travail cela va être de tout presser? Encore une fois, voulez-vous apprendre à optimiser le code MCU intégré ou à construire des instruments? Il est assez facile d'aller simplement à un MCU plus rapide si nécessaire, mais vous devez déterminer les performances du MCU dont vous avez besoin maintenant , donc six mois de travail, vous ne réalisez pas que vous ne pouvez pas tout faire fonctionner aussi vite que vous avoir besoin.

Si j'étais vous, la première chose que je ferais serait de le faire fonctionner sans truc arduino (en gros, le traiter comme un ATmega brut et utiliser AVR studio ou similaire). Ensuite, vous pouvez analyser de manière beaucoup plus efficace le type de performances dont vous avez besoin et si l'ATmega peut les gérer.

Une fois que vous êtes débarrassé des trucs arduino, vous êtes beaucoup plus libre d'utiliser différents MCU (ils sont généralement plus similaires que différents. Si vous pouvez en trouver un dans sa documentation, vous pouvez probablement faire la même chose pour les autres).

J'ai beaucoup travaillé avec les appareils ATxmega récemment, et ils sont vraiment sympas. Vous obtenez trois priorités d'interruption, ce qui facilite la gestion des éléments à temps critique. Ils sont également très agréables à travailler (conceptions périphériques saines! Structures de ports pratiques! Etc ...).

Il y a aussi les périphériques LPC de NXP, qui sont basés sur ARM, ainsi que certains des périphériques ARM d'Atmel (tels qu'utilisés sur l'Arduino Due), ou les MCU STM32 de ST. N'importe lequel d'entre eux aura des performances nettement supérieures à celles d'un ATmega, ou même d'un ATxmega.

Le principal inconvénient d'un processeur plus gros et plus puissant est le prix, mais à moins que vous ne fabriquiez des milliers de ces unités, les coûts d'assemblage et de fabrication par unité vont tellement dépasser la différence de coût (qui ne sera probablement que de quelques dollars ) qu'il est fondamentalement hors de propos.

J'avais besoin de lire sur les minuteries avant de commencer à penser à la précision du timing (construire également un séquenceur pas à pas midi avec un arduino, bien qu'il soit garanti d'avoir l'air moins cool que ceux ^^). Cette série d'articles a été la plus informative:

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

En ce moment, je pense que ma solution pour obtenir un timing précis sera.

A. Utilisez l'Arduino AVR

B. Gardez la tâche sur un microprocesseur

C. Utilisez judicieusement les détartreurs, les minuteries et les interruptions pour obtenir la précision dont vous avez besoin.

MISE À JOUR

En utilisant le tutoriel midi de base pour Arduino et après avoir lu cet article sur les minuteries et les pré-détartreurs, le code suivant est ce que j'ai trouvé. Le code utilise le mode timer1 et CTC pour jouer une note midi tous les quarts de seconde et une note éteinte tous les quarts de seconde (qui devrait être exactement 120 bpm). Malheureusement, cela arrive encore plus lentement que 120 bpm bien que ce soit le plus proche que j'ai obtenu ...

// 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);
}

MISE À JOUR

J'ai du mal avec cela depuis ~ 24 heures maintenant et j'ai finalement obtenu des réponses du forum. Je pense que le code que j'ai utilisé ci-dessus ^^ est plutôt bon. Utilisation de l'ISR, en utilisant le mode CTC et prescalers etc. Après avoir multiplié au forum , je pense que la solution est moins à atteindre une précision sur le séquenceur MIDI, mais obtenir ma configuration matérielle tout (mes synthétiseurs et échantillonneurs) accrochés à la même horloge midi, qu'elle provienne ou non de l'Arduino.

Selon la façon dont vous souhaitez progressivement passer d'un ordinateur connecté à un système basé sur µC, vous pouvez envisager de placer un Raspberry Pi à l'intérieur de cette boîte (25 à 35 $ au détail ). De cette façon, vous pouvez avoir un ordinateur Linux complet (quoique de faible puissance) avec des ports USB et des broches GPIO.