underworld theme mario

#include <stm32f10x.h>

/*
{LA, 3, DCROCHE},
            {LA, 3, DCROCHE},
            {0, 0, DCROCHE},
            {LA, 3, DCROCHE},
            {0, 0, DCROCHE},
            {FA, 3, DCROCHE},
            {LA, 3, DCROCHE},
            {0, 0, DCROCHE},
            {DO, 4, DCROCHE},
            {0, 0, DCROCHE},
            {0, 0, CROCHE},
            {0, 0, NOIRE},

            {DO, 4, DCROCHE},
            {0, 0, DCROCHE},
            {0, 0, DCROCHE},
            {LA, 3, DCROCHE},
            {0, 0, DCROCHE},
            {0, 0, DCROCHE},
            {FA, 3, DCROCHE},
            {0, 0, DCROCHE},
            {0, 0, CROCHE},
            {LAd, 3, DCROCHE},
            {0, 0, DCROCHE},
            {DO, 4, DCROCHE},
            {0, 0, DCROCHE},
            {SI, 3, DCROCHE},
            {LAd, 3, DCROCHE},
            {0, 0, RONDE}
*/

void Enable_GPIO(void)
{
        RCC->APB2ENR |= 0x013C;
}

void Init_GPIO(void)
{
        GPIOA->CRL = 0x00030004; // PA4 (Speaker) en Push-Pull et PA0 (Wake Up) en Floating Input
}

void TIM1_UP_IRQHandler(void)
{
        if (TIM1->SR & 1)
      {
                GPIOA->ODR ^= 0x10;
              TIM1->SR &= ~1;
        }
}

typedef struct
{
        int frequence; // hertz
        int octave; // 1 à 4
        int duree; // 1/4 temps
} Note;

enum
{
        DO = 65,
      DOd = 69,
        RE = 73,
      REd = 78,
      MI = 82,
      FA = 87,
      FAd = 92,
      SOL = 98,
      SOLd = 104,
      LA = 110,
      LAd = 117,
      SI = 123
};

enum
{
        RONDE = 16,
      BLANCHE = 8,
      NOIRE = 4,
        CROCHE = 2,
      DCROCHE = 1
};

int main (void)
{
        int tempo = 200*4; // bpm
        Note notes[] =
        {
                {DO, 3, NOIRE},
                {DO, 4, NOIRE},
                {LA, 2, NOIRE},
                {LA, 3, NOIRE},
                {LAd, 2, NOIRE},
                {LAd, 3, NOIRE},
                {0, 0, BLANCHE},
                {0, 0, RONDE},
                {DO, 3, NOIRE},
                {DO, 4, NOIRE},
                {LA, 2, NOIRE},
                {LA, 3, NOIRE},
                {LAd, 2, NOIRE},
                {LAd, 3, NOIRE},
                {0, 0, BLANCHE},
                {0, 0, RONDE},

                {FA, 2, NOIRE},
                {FA, 3, NOIRE},
                {RE, 2, NOIRE},
                {RE, 3, NOIRE},
                {REd, 2, NOIRE},
                {REd, 3, NOIRE},
                {0, 0, BLANCHE},
                {0, 0, RONDE},
                {FA, 2, NOIRE},
                {FA, 3, NOIRE},
                {RE, 2, NOIRE},
                {RE, 3, NOIRE},
                {REd, 2, NOIRE},
                {REd, 3, NOIRE},
                {0, 0, BLANCHE},
                {0, 0, BLANCHE},
                {REd, 3, CROCHE},
                {RE, 3, CROCHE},
                {DOd, 3, NOIRE},

                {DO, 3, BLANCHE},
                {REd, 3, BLANCHE},
                {RE, 3, BLANCHE},
                {SOLd, 2, BLANCHE},
                {SOL, 2, BLANCHE},
                {DOd, 3, BLANCHE},

                {DO, 3, CROCHE},
                {FAd, 3, CROCHE},
                {FA, 3, NOIRE},
                {MI, 3, CROCHE},
                {LAd, 3, CROCHE},
                {LA, 3, NOIRE},
                {SOLd, 3, NOIRE},
                {REd, 3, NOIRE},
                {SI, 2, BLANCHE},
                {LAd, 2, NOIRE},
                {LA, 2, NOIRE},
                {SOLd, 2, BLANCHE},

                {0, 0, RONDE},
                {0, 0, RONDE},
                {0, 0, RONDE},
        };
        int i=0, j=0;

        Enable_GPIO();
        Init_GPIO();

        /* Initialisation Timer 1 (TIM1) */

        RCC->APB2ENR |= (1 << 11); // Validation Timer 1
        TIM1->CR1    |= 0x0001; // Timer 1 Enable
        TIM1->DIER   |= 1;
        TIM1->ARR     = 500;
        *(volatile unsigned long *)0xE000E100 |= (1<<25);

        TIM1->PSC = 72000000 / TIM1->ARR / (notes[i].frequence << (notes[i].octave));

        while (1)
        {
                unsigned int cochon = 5000000*60/tempo;
                while (cochon--);

                j++;
                if (j >= notes[i].duree)
                {
                        i++;
                        TIM1->PSC = 72000000 / TIM1->ARR / (notes[i].frequence << (notes[i].octave));
                        j=0;
                }
                if (i >= sizeof(notes) / sizeof(Note))
                {
                    i = 0;
                    TIM1->PSC = 72000000 / TIM1->ARR / (notes[i].frequence << (notes[i].octave));
                }
        }
}