Минималистический четырёхголосный MIDI-проигрыватель

Предлагаемый проигрыватель не требует карты памяти, он хранит MIDI-файл длиной до 6000 байт непосредственно в микроконтроллере ATtiny85 (в отличие от этой классической конструкции, которая проигрывает WAV-файлы, и карту памяти, естественно, требует). Четырёхголосное проигрывание с затуханием при помощи ШИМ реализовано программно. Пример звучания — по ссылке.

Устройство выполнено по схеме:



Электролитический конденсатор между микроконтроллером и динамической головкой не пропустит постоянную составляющую, если в результате программного сбоя на выходе PB4 появится логическая единица. Индуктивное сопротивление головки не пропускает частоту ШИМ. Если вы решите подключить устройство к усилителю, во избежание перегрузки последнего сигналом ШИМ нужно добавить ФНЧ, как здесь.

MIDI-файл необходимо поместить в исходник прошивки в виде массива вида:

const uint8_t Tune[] PROGMEM = {
  0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x01,
  0x03, 0xc0, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x0a, 0x7e, 0x00, 0xff,
  ...
  0x50, 0xb0, 0x5b, 0x00, 0x00, 0xff, 0x2f, 0x00
};

Для перевода файла в такой формат в UNIX-подобных ОС есть готовое решение — утилита xxd. Берём MIDI-файл и пропускаем через эту утилиту так:

xxd -i musicbox.mid

В консоль будет выведено что-то вроде:

unsigned char musicbox_mid[] = {
  0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x01,
  0x03, 0xc0, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x0a, 0x7e, 0x00, 0xff,
  ...
  0x50, 0xb0, 0x5b, 0x00, 0x00, 0xff, 0x2f, 0x00
};
unsigned int musicbox_mid_len = 2708;

2708 — это длина в байтах. Получилось меньше 6000 — значит, поместится. Последовательность шестнадцатеричных чисел через буфер обмена переносим в скетч (только не забываем: в консоли — никакого Ctrl+C) вместо массива по умолчанию. Или не проделываем всего этого, если желаем его оставить.

Таймер-счётчик 1 будет работать на частоте в 64 МГц от ФАПЧ:

  PLLCSR = 1<<PCKE | 1<<PLLE; 

Переведём этот таймер в ШИМ-режим для работы в качестве ЦАП, скважность будет зависеть от значения OCR1B:

 TIMSK = 0;                     // Timer interrupts OFF
  TCCR1 = 1<<CS10;               // 1:1 prescale
  GTCCR = 1<<PWM1B | 2<<COM1B0;  // PWM B, clear on match
  OCR1B = 128;
  DDRB = 1<<DDB4;                // Enable PWM output on pin 4

Частота прямоугольных импульсов зависит от значения OCR1C, оставим его равным 255 (по умолчанию), тогда частота в 64 МГц будет поделена на 256, и получится 250 кГц.

Таймер-счётчик 0 будет вырабатывать прерывания:

  TCCR0A = 3<<WGM00;             // Fast PWM
  TCCR0B = 1<<WGM02 | 2<<CS00;   // 1/8 prescale
  OCR0A = 19;                    // Divide by 20
  TIMSK = 1<<OCIE0A;             // Enable compare match, disable overflow

Тактовая частота в 16 МГц делится делителем на 8, а затем на значение OCR0A, равное 19+1, и получается 100 кГц. Проигрыватель четырёхголосный, на каждый голос получается по 25 кГц. По прерыванию происходит выхов процедуры его обработки ISR(TIMER0_COMPA_vect), которая рассчитывает и выводит звуки.

Сторожевой таймер сконфигурирован на выработку прерывания каждые 16 мс, что требуется для получения частот нот:

WDTCR = 1<<WDIE | 0<<WDP0;     // Interrupt every 16ms

Для получения колебаний заданной формы применён прямой цифровой синтез. Аппаратного перемножения в ATtiny85 нет, поэтому берём прямоугольные импульсы и умножаем амплитуду огибающей на 1 или -1. Убывает амплитуда линейно, и чтобы рассчитать её в тот или иной момент времени, достаточно линейно же уменьшать показания счётчика.

Для каждого из каналов предусмотрено по три переменных: Freq[] — частота, Acc[] — фазовый аккумулятор, Amp[], значение амплитуды огибающей. Значения Freq[] и Acc[] суммируются. Старший бит Acc[] используется для получения прямоугольных импульсов. Чем больше Freq[], тем больше частота. Готовая форма колебаний перемножается на огибающую Amp[]. Все четыре канала мультиплексируются и поступают на аналоговый выход.

Важной частью программы является процедура обработки прерывания от таймера-счётчика 0, которая выводит колебания на аналоговый выход. Вызов этой процедуры происходит с частотой около 95 кГц. Для текущего канала c она обновляет значения Acc[c] и Amp[c], а также рассчитывает значение текущей ноты. Результат поступает на регистр сравнения OCR1B таймера-счётчика OCR1B для получения аналогового сигнала на выводе 4:

ISR(TIMER0_COMPA_vect) {
  static uint8_t c;
  signed char Temp, Mask, Env, Note;
  Acc[c] = Acc[c] + Freq[c];  
  Amp[c] = Amp[c] - (Amp[c] != 0);
  Temp = Acc[c] >> 8;
  Temp = Temp & Temp<<1;
  Mask = Temp >> 7;
  Env = Amp[c] >> Volume;
  Note = (Env ^ Mask) + (Mask & 1);
  OCR1B = Note + 128;
  c = (c + 1) & 3;
}

Строка

Acc[c] = Acc[c] + Freq[c];

прибавляет к аккумулятору Acc[c] значение частоты Freq[c]. Чем больше Freq[c], тем быстрее будет меняться значение Acc[c]. Затем строка

Amp[c] = Amp[c] - (Amp[c] != 0);

уменьшает значение амплитуды для данного канала. Фрагмент (Amp[c] != 0) нужен, чтобы после достижения амплитудой нуля она не уменьшалась дальше. Теперь строка

Temp = Acc[c] >> 8;

переносит старшие 9 бит Acc[c] в Temp. И строка

Temp = Temp & Temp<<1;

оставляет старший бит этой переменной равным единице, если единице равны два старших бита, и устанавливает старший бит в нуль, если это не так. Получаются прямоугольные импульсы с соотношением включённого и выключенного состояний 25/75. В одной из предыдущих конструкций автор применил меандр, при новом же способе гармоник получается чуть больше. Строка

Mask = Temp >> 7;

переносит в остальные биты байта значения старшего, например, если старший бит был 0, то получится 0x00, а если 1 — то 0xFF. Строка

Env = Amp[c] >> Volume;

переносит в Env тот бит Amp[c], который задан значением Volume, по умолчанию — старший, так как Volume = 8. Строка

Note = (Env ^ Mask) + (Mask & 1);

всё это объединяет. Если Mask = 0x00 то Note присваивается значение Env. Если Mask = 0xFF, то Note присваивается значение, дополнительное к Env + 1, то есть Env со знаком минуса. Теперь Note содержит текущую форму колебаний, меняющуюся от положительного до отрицательного значений текущей амплитуды. Строка

OCR1B = Note + 128;

прибавляет к Note число 128 и записывает результат в OCR1B. Строка

c = (c + 1) & 3;

выводит четыре канала по соответствующим прерываниям, мультплексируя голоса на выходе.

Двенадцать частот нот заданы в массиве:

unsigned int Scale[] = {
10973, 11626, 12317, 13050, 13826, 14648, 15519, 16442, 17419, 18455, 19552, 20715};   

Частоты нот других октав получаются делением на 2ⁿ. Например, делим 10973 на 2⁴ и получаем 686. Верхний бит Acc[c] будет переключаться с частотой в 25000/(65536/685) = 261.7 Гц.

На звучание влияют две переменных: Volume — громкость, от 7 до 9 и Decay — затухание, от 12 до 14. Чем значение Decay больше, тем медленнее затухание.

Простейший интерпретатор MIDI обращает внимание только на значения ноты, темпа и коэффициента деления, а прочие данные игнорирует. Подпрограмма readIgnore() пропускает заданное количество байт в массиве, полученном из файла:

void readIgnore (int n) {
  Ptr = Ptr + n;
}

Подпрограмма readNumber() считывает число из заданного количества байт с точностью до 4:

unsigned long readNumber (int n) {
  long result = 0;
  for (int i=0; i<n; i++) result = (result<<8) + pgm_read_byte(&Tune[Ptr++]);
  return result;
}

Подпрограмма readVariable() считывает число с принятой в MIDI переменной точностью. Количество байт при этом может быть от одного до четырёх:

unsigned long readVariable () {
  long result = 0;
  uint8_t b;
  do {
    b = pgm_read_byte(&Tune[Ptr++]);
    result = (result<<7) + (b & 0x7F);
  } while (b & 0x80);
  return result;
}

Из каждого байта берётся по семь бит, а восьмой равен единице, если дальше нужно прочитать ещё один байт, или нулю, если нет.

Интерпертатор вызывает подпрограмму noteOn() для проигрывания ноты в следующем доступном канале:

void noteOn (uint8_t number) {
  uint8_t octave = number/12;
  uint8_t note = number%12;
  unsigned int freq = Scale[note];
  uint8_t shift = 9-octave;
  Freq[Chan] = freq>>shift;
  Amp[Chan] = 1<<Decay;
  Chan = (Chan + 1) & 3;
}

Переменная Ptr указывает на следующий считываемый байт:

void playMidiData () {
  Ptr = 0;                                  // Begin at start of file

Первый блок в MIDI-файле — это заголовок, указывающий на количество дорожек, темп и коэффициент деления:

// Read header chunk
  unsigned long type = readNumber(4);
  if (type != MThd) error(1);
  unsigned long len = readNumber(4);
  unsigned int format = readNumber(2);
  unsigned int tracks = readNumber(2);
  unsigned int division = readNumber(2);    // Ticks per beat
  TempoDivisor = (long)division*16000/Tempo;

Коэффициент деления обычно равен 960. Теперь считываем заданное количество блоков:

  // Read track chunks
  for (int t=0; t<tracks; t++) {
    type = readNumber(4);
    if (type != MTrk) error(2);
    len = readNumber(4);
    EndBlock = Ptr + len;

Считываем последовательные события до окончания блока:

    // Parse track
    while (Ptr < EndBlock) {
      unsigned long delta = readVariable();
      uint8_t event = readNumber(1);
      uint8_t eventType = event & 0xF0;    
      if (delta > 0) Delay(delta/TempoDivisor);

В каждом событии задана delta — задержка в единицах времени, определяемых коэффициентом деления, которая должна произойти перед этим событием. Для событий, которые должны произойти тут де, delta равна нулю.

Метасобытия — это события типа 0xFF:

      // Meta event
      if (event == 0xFF) {
        uint8_t mtype = readNumber(1);
        uint8_t mlen = readNumber(1);
        // Tempo
        if (mtype == 0x51) {
          Tempo = readNumber(mlen);
          TempoDivisor = (long)division*16000/Tempo;
        // Ignore other meta events
        } else readIgnore(mlen);

Единственный вид интересующих нас метасобытий — это Tempo, значение темпа в микросекундах. По умолчанию оно равно 500000, то есть, полсекунды, что соответствует 120 ударам в минуту.

Остальные события — это MIDI-события, определяемые первым шестнадцатеричным разрядом своего типа. Нас интересует только 0x90 — Note On, проигрывание ноты на следующем доступном канале:

      // Note off - ignored
      } else if (eventType == 0x80) {
        uint8_t number = readNumber(1);
        uint8_t velocity = readNumber(1);
      // Note on
      } else if (eventType == 0x90) {
        uint8_t number = readNumber(1);
        uint8_t velocity = readNumber(1);
        noteOn(number);
      // Polyphonic key pressure
      } else if (eventType == 0xA0) readIgnore(2);
      // Controller change
      else if (eventType == 0xB0) readIgnore(2);
      // Program change
      else if (eventType == 0xC0) readIgnore(1);
      // Channel key pressure
      else if (eventType == 0xD0) readIgnore(1);
      // Pitch bend
      else if (eventType == 0xD0) readIgnore(2);
      else error(3);
    }
  }
}

Значение velocity игнорируем, но при желании можно устанавливать по нему начальную амплитуду ноты. Остальные события пропускаем, длина у них может быть различной. При ошибке в MIDI-файле включается светодиод.

Микроконтроллер работает на частоте в 16 МГц, чтобы кварц не требовался, нужно соответствующим образом сконфигурировать встроенный ФАПЧ. Чтобы микроконтроллер стал Arduino-совместимым, применена эта наработка Spence Konde. В меню Board выбираем подменю ATtinyCore, а там — ATtiny25/45/85. В последующих меню выбираем: Timer 1 Clock: CPU, B.O.D. Disabled, ATtiny85, 16 MHz (PLL). Затем выбираем Burn Bootloader, потом заливаем программу. Программатор применён типа Tiny AVR Programmer Board фирмы SparkFun.

Прошивка под CC-BY 4.0, в которой уже есть фуга Баха в ре миноре, находится здесь, оригинальный MIDI-файл взят здесь.