Odtwarzanie MIDI AVR hxMidiPlayer

2014-10-07T22:55:29+01:00

Witam.

Projekt odtwarzacza plików MIDI opiera się na kodzie ze strony: http://www.deep-shadows.com/hax/wordpress/?page_id=1111. Kod pierwotnie był przystosowany do kompilacji pod CodeVision AVR. Ja tylko przystosowałem kod biblioteki, aby kompilował się z AVR-GCC. Poniżej main.c dla Atmega2560, ale można łatwo przystosować do innej Atmegi z min. 4kB flash i jednym kanałem PWM pracującym w trybie Fast PWM. Na stronie autora znajdują się pliki projektu, oraz program do generowania melody.c i hxMidiPlayer_Config.h z wybranego pliku midi.

Jak konwertować swoje pliki midi do odtwarzania przez AVR? Uruchamiamy program MidiToC pobrany ze strony widocznej na górze postu. Ustawiamy "Sampling rate" na taką częstotliwość z jaką będzie pracował timer obsługujący odtwarzanie. Wybieramy ilość kanałów (proponuję zacząć od 4), wybieramy obwiednię, zaznaczamy lub nie syntetyzer perkusji (Drums syntezer) i wczytujemy plik midi za pomocą "Load midi". Program zacznie odtwarzać dźwięk mniej więcej jak nasz AVR. Po skorygowaniu ustawień tak by odpowiadały naszym upodobaniom możemy przejść do generowania plików. Klikamy "Create player config" i wklejamy ze schowka kod do pliku hxMidiPlayer_Config.h. Klikamy "Create melody code" i wklejamy do pliku melody.c.
Aby program działał pod AVR-GCC należy nanieść małe zmiany w plikach przed chwilą wygenerowanych:
- W pliku hxMidiPlayer_Config.h:

należy usunąć wszystkie wystąpienia dyrektywy flash

w tablicach s_noteFreqEx, s_sineTable, s_envelope i s_sample należy dodać atrybut PROGMEM

ew. co by nam kompilator nie pluł warningami należy zakomentować na samym końcu HXMIDIPLAYER_CONFIG_INCLUDED- W pliku melody.c:

należy usunąć wszystkie wystąpienia dyrektywy flash

w tablicach s_melody_stream1 i s_melody_stream2 oraz strukturze s_melody należy dodać atrybut PROGMEM
Po kompilacji możemy wrzucić program do AVR z podłączonym głośnikiem do wybranego pinu PWM. Na stronie autora jest kilka możliwych schematów łącznie ze schematem prostego wzmacniacza klasy D .

Tak to działa (film autora):

iframe

Poniżej kod:
main.c
[syntax=c]#include
#include
#include "melody.h"
#include "hxMidiPlayer.h"

//====================================================================
//====================================================================
// Timer0 output compare A interrupt service routine
ISR(TIMER1_COMPB_vect) {
Player_TimerFunc();
}

//====================================================================
//====================================================================
//Note: in SQUARE Waveform mode, min value is 0 and max is HXMIDIPLAYER_CHANNELS_COUNT
//In all other modes, min is 0 and max is 255, while zero level is 128.
void Player_Output(uint8_t sample) {
#ifdef HXMIDIPLAYER_WAVEFORM_SQUARE
OCR1B = sample * (1023 / HXMIDIPLAYER_CHANNELS_COUNT);
#else
OCR1B = sample * 4;
#endif
}

//====================================================================
//====================================================================
void Player_Started() {
}

//====================================================================
//====================================================================
void Player_Finished() {
Player_StartMelody(&s_melody, 255);
}

int main(void) {
// Declare your local variables here

// Port initialization
// Func7=In Func6=In Func5=In Func4=In Func3=Out Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=0 State2=T State1=T State0=T
//PORTB = 0x00;
//DDRB |= 0xff;
DDRB |= (1 << PB6);

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 16000,000 kHz
// Mode: Fast PWM top=0xFF
// OC0A output: Non-Inverted PWM
// OC0B output: Disconnected
TCCR1A |= (1 << COM1B1) | (1 << WGM11) | (1 << WGM10);
TCCR1B |= (1<TIMSK1 |= (1 << OCIE1B);

// Global enable interrupts
sei();

Player_StartMelody(&s_melody, 0);

while (1) {
// Place your code here

}
}[/syntax]
hxMidiPlayer.c
[syntax=c]#include
#include
#include
#include "hxMidiPlayer.h"

///=====================================================
// ChannelState
///=====================================================
///Single syntezer channel state
typedef struct {
#ifdef HXMIDIPLAYER_WAVEFORM_SAMPLE
//can be 24 bit uint
uint32_t m_counter;//sample index counter
#else
uint16_t m_counter; //square wave, sine or waveform generator counter
#endif
uint16_t m_counterAdd; //0 - off, 1 - drum, >0 - add value for counter

#ifdef HXMIDIPLAYER_WAVEFORM_SINE_ENVELOPE
uint8_t m_envelopeCounter;
#endif

} TChannelState;

#ifdef HXMIDIPLAYER_ENABLE_DRUMS_SYNTEZER
///=====================================================
// WhiteNoiseGeneratorState
///=====================================================
typedef struct {
uint8_t m_nze;
uint8_t m_t1;
uint8_t m_t2;
uint8_t m_t3;
}WhiteNoiseGeneratorState;
#endif

#ifdef HXMIDIPLAYER_USE_COMPRESSION
///=====================================================
/// TCompressedStreamState
///=====================================================
typedef struct {
const uint8_t* m_pData;

//number of bits still used in byte m_pData points to
uint8_t m_bitsUsed;
} TCompressedStreamState;
#endif

///=====================================================
/// TPlayerState
///=====================================================
typedef struct {
#ifdef HXMIDIPLAYER_USE_COMPRESSION
//noteNumber stream, 11 bits
TCompressedStreamState m_stream1;
//pause stream, 13 bits
TCompressedStreamState m_stream2;

const uint8_t* m_stream1_start;
const uint8_t* m_stream2_start;
#else
///pointer to next event in melody
const TPlayerStateChange* m_pMelody;
#endif

#ifdef HXMIDIPLAYER_ENABLE_DRUMS_SYNTEZER
WhiteNoiseGeneratorState m_wngState;
#endif

///This value is decreased on every timer event.
///Initially is writeln from m_delta value of StateChangeEvent.
///When it reaches 0, it's time to process state change events.
uint16_t m_eventCounter;

//255Hz counter
//initally writeln ENVELOPE_SKIP_MAX
//decreased every tick
//when reaches 0, envelope index on all channels should increase
uint8_t m_envelopeSkipCounter;

///Syntezer channels states
TChannelState m_channelState[HXMIDIPLAYER_CHANNELS_COUNT];
} TPlayerState;

///=====================================================
///=====================================================
///Player state
static TPlayerState s_playerState = {
#ifdef HXMIDIPLAYER_USE_COMPRESSION
{ NULL, 0 }, { NULL, 0 },
NULL,
NULL,
#else
NULL,
#endif
#ifdef HXMIDIPLAYER_ENABLE_DRUMS_SYNTEZER
{0, 45, 34, 53}
#endif
};

#ifdef HXMIDIPLAYER_ENABLE_DRUMS_SYNTEZER
///=====================================================
///=====================================================
static inline uint8_t Player_GetWhiteNoise() {
uint8_t b;
uint8_t b1;

s_playerState.m_wngState.m_t1 = s_playerState.m_wngState.m_nze;
s_playerState.m_wngState.m_t1 &= 66;

if ((s_playerState.m_wngState.m_t1 != 0)
&& (s_playerState.m_wngState.m_t1 < 66)) {
b = 1;
} else {
b = 0;
}

b1 = s_playerState.m_wngState.m_t2 >> 7;
s_playerState.m_wngState.m_t2 <<= 1;
s_playerState.m_wngState.m_t2 |= b;
b = s_playerState.m_wngState.m_t3 >> 7;
s_playerState.m_wngState.m_t3 <<= 1;
s_playerState.m_wngState.m_t3 |= b1;
s_playerState.m_wngState.m_nze <<= 1;
s_playerState.m_wngState.m_nze |= b;

return s_playerState.m_wngState.m_nze;
}
#endif

///=====================================================
///=====================================================
static inline uint16_t Player_GetNoteFreqAdd(uint8_t _noteNumber) {
uint8_t noteIndex;
uint8_t noteDiv;

noteIndex = 132 - 1 - _noteNumber;
noteDiv = noteIndex / 12; //how many octaves down
noteIndex = noteIndex - 12 * noteDiv;
return pgm_read_word(&s_noteFreqEx[noteIndex]) >> noteDiv;
}

#ifdef HXMIDIPLAYER_USE_COMPRESSION

///=====================================================
///=====================================================
//advance stream by number of bits
static inline void Player_Advance(TCompressedStreamState* _state,
uint16_t _bitsCount) {
uint16_t s;
s = _state->m_bitsUsed + _bitsCount;

_state->m_pData += s >> 3;
_state->m_bitsUsed = s & 0x7;
}

///=====================================================
///=====================================================
static uint16_t Player_ReadBits(TCompressedStreamState* _state,
uint8_t _bitsCount, uint16_t _mask) {
//this procedure is optimized for _bitsCount 1..16
//(value can be spread at most by 3 bytes)

uint32_t r;
int8_t s;

r = pgm_read_byte(&_state->m_pData[0]);

r <<= 8;
r |= pgm_read_byte(&_state->m_pData[1]);

r <<= 8;
r |= pgm_read_byte(&_state->m_pData[2]);

s = 24 - _bitsCount - _state->m_bitsUsed;

r >>= s;

Player_Advance(_state, _bitsCount);

return r & _mask;
}

///=====================================================
///=====================================================
//advance stream to actual data
void Player_StartStream(TCompressedStreamState* _state, uint8_t _numberOfBits) {
uint16_t s;

s = Player_ReadBits(_state, 5, 0x1f);
Player_Advance(_state, 16 + s * _numberOfBits);
}

///=====================================================
///=====================================================
static uint16_t Player_Decompress(TCompressedStreamState* _state,
const uint8_t* _streamBase, uint8_t _bitsCount, uint16_t _mask) {
uint8_t code;
TCompressedStreamState state;

code = Player_ReadBits(_state, 3, 0x7);

switch (code) {
case 0:
case 1:
case 2:
//use code as immediate value
break;

case 3:
code = 3 + Player_ReadBits(_state, 1, 1);
break;

case 4:
code = 5 + Player_ReadBits(_state, 2, 3);
break;

case 5:
code = 9 + Player_ReadBits(_state, 3, 7);
break;

case 6:
code = 17 + Player_ReadBits(_state, 3, 7);
break;

case 7:
return Player_ReadBits(_state, _bitsCount, _mask);
}

state.m_pData = _streamBase;
state.m_bitsUsed = 0;
Player_Advance(&state, 5 + 16 + ((uint16_t) code) * _bitsCount);
return Player_ReadBits(&state, _bitsCount, _mask); //review: doen't need advance
}
#endif

///=====================================================
///=====================================================
static inline void Player_ProcessEvents() {
uint8_t channelIndex;
uint8_t noteNumber;
uint16_t delta;
uint16_t cadd;

s_playerState.m_eventCounter = 0xffff;
sei();

#ifdef HXMIDIPLAYER_USE_COMPRESSION
delta = Player_Decompress(&s_playerState.m_stream1,
s_playerState.m_stream1_start, 11, 0x7ff);
noteNumber = delta & 0x7f;
channelIndex = delta >> 7;

delta = Player_Decompress(&s_playerState.m_stream2,
s_playerState.m_stream2_start, 13, 0x1fff);

if (delta == 0) {
cli();
s_playerState.m_stream1.m_pData = NULL;
Player_Finished();
return;
}

#else
delta = s_playerState.m_pMelody->m_delta;
noteNumber = s_playerState.m_pMelody->m_noteNumber;

channelIndex = delta & 0x7;
delta >>= 3;

if ( delta == 0 )
{
cli();
s_playerState.m_pMelody = NULL;
Player_Finished();
return;
}

channelIndex |= ( noteNumber >> (7 - 3 ) ) & 8;

noteNumber &= 0x7f;
#endif

if (noteNumber == 0) {
cadd = 0;
} else if (noteNumber == 1) {
cadd = 1;
} else {
cadd = Player_GetNoteFreqAdd(noteNumber);
}

#ifndef HXMIDIPLAYER_USE_COMPRESSION
s_playerState.m_pMelody++;
#endif

//mid delta is 1:
//do not hold interrupt for a long time:
//process next event on next tick event it should be processed immediatelly
//it wan't be noticable

cli();

s_playerState.m_channelState[channelIndex].m_counter = 0;
s_playerState.m_channelState[channelIndex].m_counterAdd = cadd;

#ifdef HXMIDIPLAYER_WAVEFORM_SINE_ENVELOPE
s_playerState.m_channelState[channelIndex].m_envelopeCounter = 0;
#endif

s_playerState.m_eventCounter = delta;
}

///=====================================================
///=====================================================
void Player_TimerFunc() {
uint8_t sample;
uint8_t i;
TChannelState* pState;

#ifdef HXMIDIPLAYER_USE_COMPRESSION
if (s_playerState.m_stream1.m_pData == NULL) {
return;
}
#else
if ( s_playerState.m_pMelody == NULL )
{
return;
}
#endif

//advance envelopeCounter
if (s_playerState.m_envelopeSkipCounter == 0) {
s_playerState.m_envelopeSkipCounter = ENVELOPE_SKIP_MAX;

#ifdef HXMIDIPLAYER_WAVEFORM_SINE_ENVELOPE
for (i = 0; i < HXMIDIPLAYER_CHANNELS_COUNT; i++) {
if (s_playerState.m_channelState[i].m_envelopeCounter < 255) {
s_playerState.m_channelState[i].m_envelopeCounter++;
}
}
#endif
s_playerState.m_eventCounter--;
if (s_playerState.m_eventCounter == 0) {
Player_ProcessEvents();
}
}
s_playerState.m_envelopeSkipCounter--;

//create sample

#ifdef HXMIDIPLAYER_WAVEFORM_SQUARE
sample = 0;
#else
sample = 0x80;
#endif

pState = &s_playerState.m_channelState[0];

for (i = 0; i < HXMIDIPLAYER_CHANNELS_COUNT; i++) {
#ifdef HXMIDIPLAYER_ENABLE_DRUMS_SYNTEZER
if (pState->m_counterAdd == 1) {

#ifdef HXMIDIPLAYER_WAVEFORM_SQUARE
sample += Player_GetWhiteNoise() & 1;
#else
if ( ( Player_GetWhiteNoise() & 1 ) != 0 )
{
sample += 511 / HXMIDIPLAYER_CHANNELS_COUNT / 4;
}
#endif

} else
#endif //drums syntezer
{

#ifdef HXMIDIPLAYER_WAVEFORM_SQUARE
pState->m_counter += pState->m_counterAdd;
sample += (pState->m_counter >> PLAYER_FREQ_SHR) & 1;
#endif /*HXMIDIPLAYER_WAVEFORM_SQUARE*/

#ifdef HXMIDIPLAYER_WAVEFORM_SINE
pState->m_counter += pState->m_counterAdd;
sample += pgm_read_byte(&s_sineTable[ ( pState->m_counter >> (PLAYER_FREQ_SHR - 5 ) ) & 63 ]);
#endif /*HXMIDIPLAYER_WAVEFORM_SINE*/

#ifdef HXMIDIPLAYER_WAVEFORM_SINE_ENVELOPE
{
uint8_t sineVal;
uint8_t envelopeVal;
pState->m_counter += pState->m_counterAdd;
//sineVal is unsigned value, biased by 0x80 ( 0 -> 0x80 )
sineVal =
pgm_read_byte(
&s_sineTable[ ( pState->m_counter >> (PLAYER_FREQ_SHR - 5 ) ) & 63 ]);
//envelopeVal is volume value 0..255
envelopeVal = pgm_read_byte(
&s_envelope[pState->m_envelopeCounter >> 1]);
//scale sineVal as unsigned value using simple mul/shift. We divide by 256, not 255 for simplicity.
sineVal = (uint8_t) ((((uint16_t) sineVal) * envelopeVal) >> 8);
//after scaling, 0x80 (biased zero ) became m_envelopeVal / 2
//create unsigned value by biasing back
sineVal -= envelopeVal >> 1;
sample += sineVal;
}
#endif /*HXMIDIPLAYER_WAVEFORM_SINE_ENVELOPE*/

#ifdef HXMIDIPLAYER_WAVEFORM_SAMPLE
if ( pState->m_counter < PLAYER_COUNTER_MAX_VAL )
{
pState->m_counter += pState->m_counterAdd;
}
sample += s_sample[ pState->m_counter >> (PLAYER_FREQ_SHR - 3 ) ];
#endif /*HXMIDIPLAYER_WAVEFORM_SAMPLE*/

}
pState++;
}

Player_Output(sample);
}

///=====================================================
///=====================================================
void Player_StartMelody(const TMelody* _pMelody, uint16_t _delay) {
Player_Stop();

Player_Started();

memset(s_playerState.m_channelState, 0,
sizeof(TChannelState) * HXMIDIPLAYER_CHANNELS_COUNT);

s_playerState.m_eventCounter = 1 + _delay;
s_playerState.m_envelopeSkipCounter = 0;

cli();

#ifdef HXMIDIPLAYER_USE_COMPRESSION
s_playerState.m_stream1.m_pData = (uint8_t *)pgm_read_word(&_pMelody->m_pStream1);
s_playerState.m_stream2.m_pData = (uint8_t *)pgm_read_word(&_pMelody->m_pStream2);
s_playerState.m_stream1.m_bitsUsed = 0;
s_playerState.m_stream2.m_bitsUsed = 0;

s_playerState.m_stream1_start = (uint8_t *)pgm_read_word(&_pMelody->m_pStream1);
s_playerState.m_stream2_start = (uint8_t *)pgm_read_word(&_pMelody->m_pStream2);

Player_StartStream(&s_playerState.m_stream1, 11);
Player_StartStream(&s_playerState.m_stream2, 13);
#else
s_playerState.m_pMelody = _pMelody->m_pEvents;
#endif

sei();

///Set initial values for white noise generator
//s_playerState.m_wngState.m_nze = 0;
//s_playerState.m_wngState.m_t1 = 45;
//s_playerState.m_wngState.m_t2 = 34;
//s_playerState.m_wngState.m_t3 = 53;
}

///=====================================================
///=====================================================
bool Player_IsPlaying() {
#ifdef HXMIDIPLAYER_USE_COMPRESSION
return s_playerState.m_stream1.m_pData != NULL;
#else
return s_playerState.m_pMelody != NULL;
#endif
}

///=====================================================
///=====================================================
//Wait untill player finishes playing
void Player_WaitFinish() {
while (Player_IsPlaying() == true)
;
}

///=====================================================
///=====================================================
void Player_Stop() {
if (Player_IsPlaying()) {
cli();

#ifdef HXMIDIPLAYER_USE_COMPRESSION
s_playerState.m_stream1.m_pData = NULL;
#else
s_playerState.m_pMelody = NULL;
#endif

sei();

Player_Finished();
}
}[/syntax]
hxMidiPlayer.h
[syntax=c]#ifndef HXMIDIPLAYER_H_
#define HXMIDIPLAYER_H_

#include
#include
#include
#include "hxMidiPlayer_Config.h"

#ifdef HXMIDIPLAYER_USE_COMPRESSION

///=====================================================
///=====================================================
typedef struct {
const uint8_t* m_pStream1;
const uint8_t* m_pStream2;
} TMelody;

#else

///=====================================================
///=====================================================
typedef struct {
//highest bit is highest for channel index
uint8_t m_noteNumber;

///15-3 bits - Delta value, 2,1,0 bits - channel index
uint16_t m_delta;
} TPlayerStateChange;

///=====================================================
///=====================================================
typedef struct {
const TPlayerStateChange* m_pEvents;
} TMelody;

#endif

//======== Timer function ===========

///Timer event function, should be called by user with fixed frequency HXMIDIPLAYER_SAMPLING_RATE
extern void Player_TimerFunc();

//======== Callbacks ===========

///Called by player to output data to DAC/pwm
extern void Player_Output(uint8_t sample);

///Called by player when player starts to play
///( from Player_StartMelody() )
///Can be used to configure timer/pwm
extern void Player_Started();

///Called by player when melody is finished
///( from Player_TimerFunc(), interrupts disabled )
///Can be used to configure timer/pwm
extern void Player_Finished();

// ======== Control functions ===========

///Start playing melody
//Previously played melody is stoped, Player_Finished callback is called.
//Player_Started() callback is called on start.
//_delay - start delay in 255Hz ticks, max is 65534
extern void Player_StartMelody(const TMelody* _pMelody, uint16_t _delay);

/// ======== Misc functions ===========

///Is player currently playing ?
extern bool Player_IsPlaying();

///Wait untill player finish playing
//If not playing currently, returns immediatelly.
extern void Player_WaitFinish();

//Stop currently played melody.
//Player_Finished() callback is called if was playing.
//If melody is not playing - call is ignored completely.
void Player_Stop();

#endif /*HXMIDIPLAYER_H_*/[/syntax]
wygenerowany hxMidiPlayer_Config.h po poprawkach
[syntax=c]#ifndef HXMIDIPLAYER_CONFIG_INCLUDED
#define HXMIDIPLAYER_CONFIG_INCLUDED

#include

//=====================================================
//=====================================================
//Player settings:
//Channels count: 8
//Frequency: 15625
//Pitch: 0
//Waveform: EWK_SQUARE

//uncomment to place note frequency table in eeprom
//#define NOTES_TO_EEPROM

//=====================================================
//=====================================================
#define HXMIDIPLAYER_SAMPLING_RATE 15625
#define HXMIDIPLAYER_CHANNELS_COUNT 8
#define HXMIDIPLAYER_WAVEFORM_SQUARE
#define HXMIDIPLAYER_ENABLE_DRUMS_SYNTEZER
#define HXMIDIPLAYER_USE_COMPRESSION
#define ENVELOPE_SKIP_MAX 61

//Player frequency = 15625
//Pitch = 0
#define PLAYER_FREQ_SHR 14
#define PLAYER_COUNTER_MAX_VAL 0
static const
#ifdef NOTES_TO_EEPROM
//eeprom
#else
//flash
#endif
uint16_t PROGMEM s_noteFreqEx[ 12 ] PROGMEM = {0x8178, 0x7A34, 0x7357, 0x6CDF, 0x66C2, 0x60FE, 0x5B8C, 0x5668, 0x518F, 0x4CFB, 0x48A9, 0x4495};

#endif /*HXMIDIPLAYER_CONFIG_INCLUDED*/[/syntax]
wygenerowane melody.c po porawkach
[syntax=c]#include "melody.h"

//Player frequency=15625
//Player minimum channels count =8
const uint8_t s_melody_stream1[2008] PROGMEM = { 200, 82, 240, 128, 16, 36, 0, 192, 0,
3, 2, 18, 9, 184, 76, 38, 4, 240, 37, 4, 241, 144, 64, 70, 41, 52, 8,
99, 16, 35, 140, 18, 148, 21, 2, 136, 1, 159, 24, 92, 153, 65, 166, 121,
66, 230, 200, 58, 105, 241, 133, 201, 148, 25, 194, 143, 24, 92, 153,
65, 166, 121, 66, 230, 200, 58, 106, 248, 199, 229, 6, 12, 225, 17, 198,
28, 145, 4, 17, 30, 48, 37, 6, 112, 136, 195, 139, 203, 224, 206, 136,
225, 3, 139, 122, 32, 206, 136, 35, 132, 94, 47, 57, 53, 116, 70, 92,
95, 74, 12, 232, 142, 17, 184, 189, 228, 219, 132, 83, 79, 54, 161, 211,
17, 30, 48, 239, 131, 79, 140, 58, 96, 213, 217, 202, 4, 27, 99, 202,
71, 56, 33, 211, 112, 155, 119, 39, 208, 106, 207, 41, 28, 224, 7, 76,
68, 248, 195, 165, 209, 17, 227, 3, 147, 152, 53, 71, 148, 62, 110, 198,
77, 197, 244, 157, 16, 68, 120, 192, 148, 25, 194, 35, 14, 47, 47, 131,
58, 35, 132, 14, 45, 232, 131, 58, 32, 142, 17, 120, 188, 228, 213, 209,
25, 113, 125, 40, 51, 162, 56, 70, 226, 247, 147, 110, 17, 77, 60, 218,
135, 76, 68, 120, 195, 190, 13, 62, 48, 233, 131, 87, 103, 40, 16, 109,
143, 41, 28, 224, 135, 77, 194, 109, 220, 159, 65, 171, 60, 163, 243,
128, 29, 49, 19, 227, 14, 151, 68, 71, 140, 14, 78, 96, 213, 30, 80,
121, 187, 25, 55, 23, 210, 116, 65, 20, 16, 171, 227, 50, 213, 194, 116,
143, 57, 99, 132, 214, 58, 14, 18, 215, 24, 239, 65, 19, 178, 212, 252,
154, 145, 85, 201, 200, 141, 212, 193, 157, 17, 194, 46, 113, 228, 212,
243, 138, 42, 68, 59, 80, 66, 175, 140, 203, 87, 9, 215, 158, 114, 199,
9, 172, 116, 28, 37, 174, 49, 222, 68, 78, 202, 96, 206, 136, 215, 140,
222, 83, 221, 17, 175, 25, 188, 167, 193, 181, 60, 166, 243, 158, 29,
55, 37, 100, 34, 40, 33, 87, 198, 101, 171, 132, 233, 30, 114, 199, 9,
172, 116, 28, 37, 174, 49, 222, 130, 39, 101, 169, 249, 53, 34, 171,
147, 145, 27, 169, 131, 58, 35, 132, 92, 227, 201, 169, 231, 20, 84,
136, 118, 35, 132, 187, 57, 56, 131, 58, 32, 138, 179, 228, 233, 209, 4,
71, 140, 10, 96, 206, 17, 18, 34, 68, 42, 8, 68, 80, 66, 175, 140, 203,
87, 9, 210, 60, 229, 142, 19, 88, 232, 56, 75, 92, 99, 189, 4, 78, 203,
83, 242, 106, 69, 87, 39, 34, 55, 83, 6, 116, 71, 8, 185, 199, 147, 83,
206, 40, 169, 16, 237, 65, 10, 190, 51, 45, 92, 39, 94, 121, 203, 28,
38, 177, 208, 112, 150, 184, 199, 121, 17, 59, 41, 131, 58, 35, 94, 51,
121, 79, 116, 70, 188, 102, 242, 159, 6, 212, 242, 155, 206, 120, 116,
220, 149, 144, 136, 160, 133, 95, 25, 150, 174, 19, 164, 121, 203, 28,
38, 177, 208, 112, 150, 184, 199, 122, 8, 157, 150, 167, 228, 212, 138,
174, 78, 68, 110, 166, 12, 232, 142, 17, 115, 143, 38, 167, 156, 81, 82,
33, 216, 142, 18, 236, 228, 226, 12, 232, 130, 42, 207, 147, 167, 68,
17, 30, 48, 41, 131, 56, 68, 72, 137, 16, 168, 33, 17, 28, 121, 44, 137,
229, 16, 58, 34, 56, 242, 103, 6, 116, 68, 113, 181, 85, 201, 193, 231,
24, 59, 34, 39, 100, 160, 219, 242, 134, 232, 142, 17, 120, 192, 162,
13, 129, 229, 0, 58, 35, 146, 178, 17, 17, 199, 146, 200, 158, 81, 3,
162, 35, 143, 38, 112, 103, 68, 71, 27, 85, 92, 156, 30, 113, 132, 216,
242, 134, 30, 68, 34, 8, 160, 132, 65, 28, 149, 144, 136, 142, 60, 150,
68, 242, 136, 29, 17, 28, 121, 51, 131, 58, 34, 56, 218, 170, 228, 224,
243, 140, 29, 145, 19, 178, 80, 109, 249, 67, 116, 71, 8, 188, 96, 81,
6, 192, 242, 128, 29, 17, 201, 89, 8, 137, 241, 133, 201, 148, 26, 103,
148, 46, 108, 131, 166, 159, 24, 92, 153, 65, 156, 40, 241, 133, 201,
148, 26, 103, 148, 46, 108, 131, 166, 175, 140, 126, 80, 96, 206, 17,
28, 97, 201, 16, 65, 17, 227, 2, 80, 103, 8, 140, 56, 188, 190, 12, 232,
142, 16, 56, 183, 162, 12, 232, 130, 56, 69, 226, 243, 147, 87, 68, 101,
197, 244, 160, 206, 136, 225, 27, 139, 222, 77, 184, 69, 52, 243, 106,
29, 49, 17, 227, 14, 248, 52, 248, 195, 166, 13, 93, 156, 160, 65, 182,
60, 164, 115, 130, 29, 55, 9, 183, 114, 125, 6, 172, 242, 145, 206, 0,
116, 196, 79, 140, 58, 93, 17, 30, 48, 57, 57, 131, 84, 121, 67, 230,
236, 100, 220, 95, 73, 209, 4, 71, 140, 9, 65, 156, 34, 48, 226, 242,
248, 51, 162, 56, 64, 226, 222, 136, 51, 162, 8, 225, 23, 139, 206, 77,
93, 17, 151, 23, 210, 131, 58, 35, 132, 110, 47, 121, 54, 225, 20, 211,
205, 168, 116, 196, 71, 140, 59, 224, 211, 227, 14, 152, 53, 118, 114,
129, 6, 216, 242, 145, 206, 8, 116, 220, 38, 221, 201, 244, 26, 179,
202, 63, 56, 1, 211, 17, 62, 48, 233, 116, 68, 120, 192, 228, 230, 13,
81, 229, 7, 155, 177, 147, 113, 125, 39, 68, 17, 65, 10, 190, 51, 45,
92, 39, 72, 243, 150, 56, 77, 99, 160, 225, 45, 113, 142, 244, 17, 59,
45, 79, 201, 169, 21, 92, 156, 136, 221, 76, 25, 209, 28, 34, 231, 30,
77, 79, 56, 162, 164, 67, 181, 4, 42, 248, 204, 181, 112, 157, 121, 231,
44, 112, 154, 199, 65, 194, 90, 227, 29, 228, 68, 236, 166, 12, 232,
141, 120, 205, 229, 61, 209, 26, 241, 155, 202, 124, 27, 83, 202, 111,
57, 225, 211, 114, 86, 66, 34, 130, 21, 124, 102, 90, 184, 78, 145, 231,
44, 112, 154, 199, 65, 194, 90, 227, 29, 232, 34, 118, 90, 159, 147, 82,
42, 185, 57, 17, 186, 152, 51, 162, 56, 69, 206, 60, 154, 158, 113, 69,
72, 135, 98, 56, 75, 179, 147, 136, 51, 162, 8, 171, 62, 78, 157, 16,
68, 120, 192, 166, 12, 225, 17, 34, 36, 66, 160, 132, 69, 4, 42, 248,
204, 181, 112, 157, 35, 206, 88, 225, 53, 142, 131, 132, 181, 198, 59,
208, 68, 236, 181, 63, 38, 164, 85, 114, 114, 35, 117, 48, 103, 68, 112,
139, 156, 121, 53, 60, 226, 138, 145, 14, 212, 16, 171, 227, 50, 213,
194, 117, 231, 156, 177, 194, 107, 29, 7, 9, 107, 140, 119, 145, 19,
178, 152, 51, 162, 53, 227, 55, 148, 247, 68, 107, 198, 111, 41, 240,
109, 79, 41, 188, 231, 135, 77, 201, 89, 8, 138, 8, 85, 241, 153, 106,
225, 58, 71, 156, 177, 194, 107, 29, 7, 9, 107, 140, 119, 160, 137, 217,
106, 126, 77, 72, 170, 228, 228, 70, 234, 96, 206, 136, 225, 23, 56,
242, 106, 121, 197, 21, 34, 29, 136, 225, 46, 206, 78, 32, 206, 136, 34,
172, 249, 58, 116, 65, 17, 227, 2, 152, 51, 132, 68, 136, 145, 10, 130,
17, 17, 199, 146, 200, 158, 81, 3, 162, 35, 143, 38, 112, 103, 68, 71,
27, 85, 92, 156, 30, 113, 131, 178, 34, 118, 74, 13, 191, 40, 110, 136,
225, 23, 140, 10, 32, 216, 30, 80, 3, 162, 57, 43, 33, 17, 28, 121, 44,
137, 229, 16, 58, 34, 56, 242, 103, 6, 116, 68, 113, 181, 85, 201, 193,
231, 24, 77, 143, 40, 97, 228, 66, 32, 138, 8, 68, 17, 201, 89, 8, 136,
227, 201, 100, 79, 40, 129, 209, 17, 199, 147, 56, 51, 162, 35, 141,
170, 174, 78, 15, 56, 193, 217, 17, 59, 37, 6, 223, 148, 55, 68, 112,
139, 198, 5, 16, 108, 15, 40, 1, 209, 28, 149, 144, 136, 159, 24, 92,
153, 65, 166, 121, 66, 230, 200, 58, 105, 241, 133, 201, 148, 25, 194,
143, 24, 92, 153, 65, 166, 121, 66, 230, 200, 58, 106, 248, 199, 229, 6,
12, 225, 17, 198, 28, 145, 4, 17, 30, 48, 37, 6, 112, 136, 195, 139,
203, 224, 206, 136, 225, 3, 139, 122, 32, 206, 136, 35, 132, 94, 47, 57,
53, 116, 70, 92, 95, 74, 12, 232, 142, 17, 184, 189, 228, 219, 132, 83,
79, 54, 161, 211, 17, 30, 48, 239, 131, 79, 140, 58, 96, 213, 217, 202,
4, 27, 99, 202, 71, 56, 33, 211, 112, 155, 119, 39, 208, 106, 207, 41,
28, 224, 7, 76, 68, 248, 195, 165, 209, 17, 227, 3, 147, 152, 53, 71,
148, 62, 110, 198, 77, 197, 244, 157, 16, 68, 120, 192, 148, 25, 194,
35, 14, 47, 47, 131, 58, 35, 132, 14, 45, 232, 131, 58, 32, 142, 17,
120, 188, 228, 213, 209, 25, 113, 125, 40, 51, 162, 56, 70, 226, 247,
147, 110, 17, 77, 60, 218, 135, 76, 68, 120, 195, 190, 13, 62, 48, 233,
131, 87, 103, 40, 16, 109, 143, 41, 28, 224, 135, 77, 194, 109, 220,
159, 65, 171, 60, 163, 243, 128, 29, 49, 19, 227, 14, 151, 68, 71, 140,
14, 78, 96, 213, 30, 80, 121, 187, 25, 55, 23, 210, 116, 65, 19, 178,
136, 50, 193, 200, 195, 140, 9, 65, 157, 17, 194, 39, 24, 20, 65, 157,
17, 194, 46, 124, 154, 193, 184, 77, 87, 57, 28, 38, 221, 76, 27, 126,
80, 92, 44, 249, 53, 221, 214, 239, 148, 143, 56, 99, 102, 92, 102, 218,
182, 151, 25, 176, 109, 143, 41, 188, 219, 138, 219, 140, 206, 78, 96,
220, 38, 241, 149, 201, 220, 24, 207, 148, 142, 111, 3, 183, 24, 114,
35, 132, 94, 48, 45, 88, 80, 121, 192, 14, 200, 130, 39, 101, 16, 101,
131, 145, 135, 24, 18, 131, 58, 35, 132, 78, 48, 40, 131, 58, 35, 132,
92, 249, 53, 131, 112, 154, 174, 114, 56, 77, 186, 152, 54, 252, 160,
184, 89, 242, 107, 187, 173, 223, 9, 17, 194, 111, 25, 74, 213, 194,
108, 184, 202, 131, 112, 154, 116, 230, 220, 77, 172, 228, 230, 13, 87,
24, 252, 157, 193, 140, 105, 24, 39, 145, 28, 32, 16, 184, 60, 160, 135,
68, 17, 30, 48, 37, 6, 112, 136, 195, 139, 203, 224, 206, 136, 225, 3,
139, 122, 32, 206, 136, 35, 132, 94, 47, 57, 53, 116, 70, 92, 95, 74,
12, 232, 142, 17, 184, 189, 228, 219, 132, 83, 79, 54, 161, 211, 17, 30,
48, 239, 131, 79, 140, 58, 96, 213, 217, 202, 4, 27, 99, 202, 71, 56,
33, 211, 112, 155, 119, 39, 208, 106, 207, 41, 28, 224, 7, 76, 68, 248,
195, 165, 209, 17, 227, 3, 147, 152, 53, 71, 148, 62, 110, 198, 77, 197,
244, 157, 16, 68, 120, 192, 148, 25, 194, 35, 14, 47, 47, 131, 58, 35,
132, 14, 45, 232, 131, 58, 32, 142, 17, 120, 188, 228, 213, 209, 25,
113, 125, 40, 51, 162, 56, 70, 226, 247, 147, 110, 17, 77, 60, 218, 135,
76, 68, 120, 195, 190, 13, 62, 48, 233, 131, 87, 103, 40, 16, 109, 143,
41, 28, 224, 135, 77, 194, 109, 220, 159, 65, 171, 60, 163, 243, 128,
29, 49, 19, 227, 14, 151, 68, 71, 140, 14, 78, 96, 213, 30, 80, 121,
187, 25, 55, 23, 210, 116, 65, 112 };

const uint8_t s_melody_stream2[1142] PROGMEM = { 104, 82, 240, 0, 64, 6, 2, 224, 1, 0,
88, 3, 32, 34, 1, 40, 18, 0, 42, 0, 192, 38, 0, 0, 0, 98, 0, 49, 2, 64,
3, 16, 36, 0, 49, 0, 24, 129, 192, 76, 0, 49, 2, 163, 17, 32, 98, 98,
98, 0, 40, 8, 20, 0, 103, 0, 204, 0, 80, 12, 229, 1, 0, 10, 0, 51, 128,
80, 16, 0, 20, 0, 103, 0, 20, 4, 13, 0, 65, 156, 0, 80, 16, 0, 20, 0,
103, 0, 20, 4, 0, 40, 0, 206, 0, 40, 1, 0, 10, 103, 0, 20, 4, 10, 0, 51,
128, 102, 0, 40, 6, 114, 128, 128, 5, 0, 25, 192, 40, 8, 0, 10, 0, 51,
128, 10, 2, 6, 128, 32, 206, 0, 40, 8, 0, 10, 0, 51, 128, 10, 2, 0, 20,
0, 103, 0, 20, 0, 128, 5, 51, 130, 160, 1, 64, 6, 112, 1, 64, 64, 2,
128, 103, 0, 160, 32, 10, 0, 51, 128, 80, 128, 0, 160, 25, 192, 5, 64,
2, 128, 12, 224, 2, 128, 128, 5, 0, 25, 192, 40, 8, 0, 80, 1, 156, 0,
80, 16, 5, 6, 112, 84, 0, 40, 0, 206, 0, 40, 8, 0, 80, 12, 224, 20, 4,
1, 64, 6, 112, 10, 16, 0, 20, 3, 56, 6, 96, 2, 128, 103, 40, 8, 0, 83,
56, 0, 160, 32, 80, 103, 5, 64, 20, 25, 193, 80, 0, 160, 3, 56, 0, 160,
32, 1, 64, 51, 128, 80, 16, 5, 0, 25, 192, 40, 64, 0, 80, 12, 224, 2,
160, 1, 64, 6, 112, 1, 64, 64, 2, 128, 12, 224, 20, 4, 0, 40, 0, 206, 0,
40, 8, 2, 131, 56, 42, 0, 20, 0, 103, 0, 20, 4, 0, 40, 6, 112, 10, 2, 0,
160, 3, 56, 5, 8, 0, 10, 1, 156, 3, 48, 1, 64, 51, 148, 4, 0, 41, 156,
0, 80, 16, 40, 51, 130, 160, 10, 12, 224, 72, 3, 16, 12, 64, 6, 32, 24,
128, 98, 0, 49, 0, 24, 128, 12, 65, 136, 49, 0, 24, 128, 98, 1, 136, 49,
6, 32, 72, 3, 16, 12, 64, 6, 32, 24, 128, 98, 0, 49, 0, 24, 128, 98, 12,
76, 65, 136, 49, 49, 6, 32, 196, 9, 0, 98, 1, 136, 0, 196, 3, 16, 12,
64, 6, 32, 3, 16, 1, 136, 49, 6, 32, 3, 16, 12, 64, 49, 6, 32, 196, 0,
98, 0, 49, 2, 64, 3, 16, 36, 0, 49, 0, 24, 129, 192, 76, 0, 49, 2, 163,
17, 32, 98, 98, 98, 0, 40, 8, 20, 0, 103, 0, 204, 0, 80, 12, 229, 1, 0,
10, 0, 51, 128, 80, 16, 0, 20, 0, 103, 0, 20, 4, 13, 0, 65, 156, 0, 80,
16, 0, 20, 0, 103, 0, 20, 4, 0, 40, 0, 206, 0, 40, 1, 0, 10, 103, 0, 20,
4, 10, 0, 51, 128, 102, 0, 40, 6, 114, 128, 128, 5, 0, 25, 192, 40, 8,
0, 10, 0, 51, 128, 10, 2, 6, 128, 32, 206, 0, 40, 8, 0, 10, 0, 51, 128,
10, 2, 0, 20, 0, 103, 0, 20, 0, 128, 5, 51, 130, 160, 1, 64, 6, 112, 1,
64, 64, 2, 128, 103, 0, 160, 32, 10, 0, 51, 128, 80, 128, 0, 160, 25,
192, 5, 64, 2, 128, 12, 224, 2, 128, 128, 5, 0, 25, 192, 40, 8, 0, 80,
1, 156, 0, 80, 16, 5, 6, 112, 84, 0, 40, 0, 206, 0, 40, 8, 0, 80, 12,
224, 20, 4, 1, 64, 6, 112, 10, 16, 0, 20, 3, 56, 6, 96, 2, 128, 103, 40,
8, 0, 83, 56, 0, 160, 32, 80, 103, 5, 64, 20, 25, 193, 80, 0, 160, 3,
56, 0, 160, 32, 1, 64, 51, 128, 80, 16, 5, 0, 25, 192, 40, 64, 0, 80,
12, 224, 2, 160, 1, 64, 6, 112, 1, 64, 64, 2, 128, 12, 224, 20, 4, 0,
40, 0, 206, 0, 40, 8, 2, 131, 56, 42, 0, 20, 0, 103, 0, 20, 4, 0, 40, 6,
112, 10, 2, 0, 160, 3, 56, 5, 8, 0, 10, 1, 156, 3, 48, 1, 64, 51, 148,
4, 0, 41, 156, 0, 80, 16, 40, 51, 130, 160, 10, 12, 224, 72, 3, 16, 12,
64, 6, 32, 24, 128, 98, 0, 49, 0, 24, 128, 12, 65, 136, 49, 0, 24, 128,
98, 1, 136, 49, 6, 32, 72, 3, 16, 12, 64, 6, 32, 24, 128, 98, 0, 49, 0,
24, 128, 98, 12, 76, 65, 136, 49, 49, 6, 32, 196, 9, 0, 98, 1, 136, 0,
196, 3, 16, 12, 64, 6, 32, 3, 16, 1, 136, 49, 6, 32, 3, 16, 12, 64, 49,
6, 32, 196, 0, 98, 0, 49, 2, 64, 3, 16, 36, 0, 49, 0, 24, 129, 192, 76,
0, 49, 2, 163, 17, 32, 98, 98, 98, 0, 40, 8, 20, 0, 103, 0, 204, 0, 80,
12, 229, 1, 0, 10, 0, 51, 128, 80, 16, 0, 20, 0, 103, 0, 20, 4, 13, 0,
65, 156, 0, 80, 16, 0, 20, 0, 103, 0, 20, 4, 0, 40, 0, 206, 0, 40, 1, 0,
10, 103, 0, 20, 4, 10, 0, 51, 128, 102, 0, 40, 6, 114, 128, 128, 5, 0,
25, 192, 40, 8, 0, 10, 0, 51, 128, 10, 2, 6, 128, 32, 206, 0, 40, 8, 0,
10, 0, 51, 128, 10, 2, 0, 20, 0, 103, 0, 20, 0, 128, 5, 51, 128, 10, 16,
5, 0, 25, 192, 51, 0, 20, 3, 56, 0, 160, 32, 10, 0, 51, 130, 132, 0, 40,
51, 128, 10, 0, 64, 208, 4, 25, 192, 5, 0, 32, 104, 2, 12, 224, 2, 128,
128, 40, 6, 112, 1, 64, 64, 166, 112, 1, 66, 0, 160, 3, 56, 6, 96, 2,
128, 103, 0, 20, 4, 1, 64, 6, 112, 80, 128, 5, 6, 112, 10, 2, 6, 128,
32, 206, 0, 40, 1, 3, 64, 16, 103, 0, 170, 105, 0, 160, 220, 1, 84, 128,
85, 52, 148, 206, 0, 40, 8, 20, 0, 103, 0, 204, 0, 80, 12, 229, 1, 0,
10, 0, 51, 128, 80, 16, 0, 20, 0, 103, 0, 20, 4, 13, 0, 65, 156, 0, 80,
16, 0, 20, 0, 103, 0, 20, 4, 0, 40, 0, 206, 0, 40, 1, 0, 10, 103, 0, 20,
4, 10, 0, 51, 128, 102, 0, 40, 6, 114, 128, 128, 5, 0, 25, 192, 40, 8,
0, 10, 0, 51, 128, 10, 2, 6, 128, 32, 206, 0, 40, 8, 0, 10, 0, 51, 128,
10, 2, 0, 20, 0, 103, 0, 20, 0, 128, 5, 10, 192 };

const TMelody s_melody PROGMEM = { s_melody_stream1, s_melody_stream2 };[/syntax]
melody.h
[syntax=c]#ifndef MELODY_H_
#define MELODY_H_

#include "hxMidiPlayer.h"

extern const TMelody s_melody;

#endif /*MELODY_H_*/[/syntax]

Powyższy kod jest uruchomiony na 16 bitowym timerze. W przypadku uruchamiania na 8 bitowym timerze funkcja Player_Output powinna wyglądać tak:[syntax=c]void Player_Output(uint8_t sample) {
#ifdef HXMIDIPLAYER_WAVEFORM_SQUARE
OCR1B = sample * (255 / HXMIDIPLAYER_CHANNELS_COUNT);
#else
OCR1B = sample;
#endif
}[/syntax]
Jak ktoś jest oblatany w Deplhi mógłby pomóc zmienić kod MidiToC tak by generował gotowe pliki pod AVR-GCC. Źródełka programu znajdują się na stronie autora. Uwaga synteza dźwięku nie jest lekkim zadaniem dla małych AVR-ków, więc polecam zegar min. 16MHz (nie próbowałem na niższym). Zegar będzie głównym ogranicznikiem ilości kanałów i częstotliwości próbkowania z jaką będziemy mogli odtwarzać melodie. Więcej na ten temat na stronie autora.

Statystyki: Napisane przez ryba84 — 25 wrz 2014, o 16:44

ATNEL tech-forum

Re: Odtwarzanie MIDI AVR hxMidiPlayer

Re: Odtwarzanie MIDI AVR hxMidiPlayer

Re: Odtwarzanie MIDI AVR hxMidiPlayer

Re: Odtwarzanie MIDI AVR hxMidiPlayer

Re: Odtwarzanie MIDI AVR hxMidiPlayer

Re: Odtwarzanie MIDI AVR hxMidiPlayer

Re: Odtwarzanie MIDI AVR hxMidiPlayer

Re: Odtwarzanie MIDI AVR hxMidiPlayer

Odtwarzanie MIDI AVR hxMidiPlayer