Mały odtwarzacz MP3,AAC,MP4 na AT91SAM7S256

void compare_tc1_irq_handler(void) __attribute__ ((interrupt ("TC1")));
void compare_tc1_irq_handler(void)   //procedura obsługująca przerwanie pochodzące od zrównania się zawartości TC1 z zawartością rejestru TC1_RC
{
 unsigned int dummy;
 dummy=*AT91C_AIC_IVR; //odczyt z rejestru IVR,sygnalizuje, że rozpoczęłą sie obsługa przerwania 
 dummy=*AT91C_TC1_SR;  //odczyt z rejestru statusu TC1.Musi być ten odczyt,by możliwe było przyjmowanie dalszych przerwań od TC1
                      //gdy tego odczytu nie było, to przerwanie przyjmowane i wykonywane było tylko raz
 if ( (AT91F_PIO_GetInput(AT91C_BASE_PIOA) & L3CLK ) == L3CLK )  //realizacja sygnału zegarowego na wejściu L3CLK przetwornika UDA1330
 { //teraz przygotowanie nowego bitu z dana_do_wyslania do wystawienia na linię L3DATA
   AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, L3CLK ); //jeśli było L3CLK = H ,to teraz wyzerowanie L3CLK = L (wytworzenie zbocza opadającego na L3CLK)
   if ((dana_do_wyslania & 0x01) == 0) //gdy najmłodszy bit danej do wysłania == 0,to
       AT91F_PIO_ClearOutput( AT91C_BASE_PIOA, L3DATA); //wyzerowanie linii L3DATA
   else //w przeciwnym razie, gdy najmłodszy bit danej do wysłania <> 0, to
       AT91F_PIO_SetOutput( AT91C_BASE_PIOA, L3DATA); //ustawienie linii L3DATA.W efekcie stan linii L3DATA będzie podążać za stanem najmłodszego bitu danej do wysłania
   dana_do_wyslania = dana_do_wyslania >> 1;
 }
 else
 {
   AT91F_PIO_SetOutput( AT91C_BASE_PIOA, L3CLK );  //w przeciwnym razie, gdy było L3CLK = L, to teraz ustawienie L3CLK = H (wytworzenie zbocza narastającego na L3CLK (zapisującego bit do DAC))
   licznik_wyslanych_bitow++; //zwiększenie o 1 licznika wysłanych bitów, bo poprzez wytworzenie zbocza narastającego na L3CLK dany bit już został wysłany do DAC
 }
 if ((licznik_wyslanych_bitow == 8) & (AT91F_PIO_GetInput(AT91C_BASE_PIOA) & L3CLK ) == L3CLK) dana_juz_wyslana = true;
 //gdy już liczba wysłanych bitów = 8 i poziom na L3CLK = H (już ostatnie zbocze narastające zostało wytworzone), to ustawienie dana_juz_wyslana = true
 *AT91C_AIC_EOICR = 0; //zapis do rejestru EOICR sygnalizuje, że zakończyła się obsługa bieżącego przerwania 
}

unsigned char konfig_glosnosci[] = {0x14,               //0b00010100 - adres UDA1330 i wybrany rejestr danych (2 najmłodsze bity = 00)
                                     nastawa_glosnosci / 2}; //dana wpisywana do rejestru danych (wartość nastawy głośności jest dzielona przez 2, by uzyskać
                                                             //zmniejszenie szybkości regulacji głośności w górę i w dół )

        if (! (configured)) // gdy była to dopiero pierwsza poprawnie zdekodowana ramka (wtedy configured == false), to najpierw przed wysłaniem danych do portu SSC
        { //skonfigurowanie interfejsu SSC
          sampling_freq = mp3FrameInfo.samprate; //odczytanie częstotliwości próbkowania
          AT91F_PMC_EnablePeriphClock( AT91C_BASE_PMC, 1 << AT91C_ID_SSC ) ;  //enable the clock of the SSC
          if (sampling_freq == 48000) 
          { //gdy częstotliwość próbkowania odczytana z odtwarzanego pliku = 48kHz, to poniżej takie ustawienie clk mikrokontrolera, by przy jeszcze 0WS fsample było jak najbliższe 48kHz (co wpływa na szybkość odtwarzania)
            AT91F_CKGR_CfgPLLReg(AT91C_BASE_CKGR, AT91C_CKGR_USBDIV_0 | (256 << 16) | AT91C_CKGR_OUT_0 | AT91C_CKGR_PLLCOUNT | 100); //mikrokontroler taktowany jest zegarem (18,432 * (256+1) / 100) ~= 47,4MHz (dla takiej fclk mikrokontroler pracuje jeszcze stabilnie (bez zwisów))
         // AT91F_CKGR_CfgPLLReg(AT91C_BASE_CKGR, AT91C_CKGR_USBDIV_0 | (7 << 16) | AT91C_CKGR_OUT_0 | AT91C_CKGR_PLLCOUNT | 3); //mikrokontroler taktowany jest zegarem (18,432 * (7+1) / 3) = 49,152MHz (taka powinna być fclk mikrokontrolera)
            while (! (AT91F_PMC_IsStatusSet(AT91C_BASE_PMC, AT91C_PMC_LOCK))){}; //w pętli while odczekanie na ustabilizowanie się pętli PLL
            AT91F_SSC_Configure( AT91C_BASE_SSC, (47370240), (2*16*46260), 0, 0, AT91C_I2S_ASY_MASTER_TX_SETTING(16, 2), AT91C_I2S_ASY_TX_FRAME_SETTING(16, 2)); //(dla zegara 47,4MHz; fsample = fclk/1024 ~= 46,3kHz i jeszcze 0WS)
        //  AT91F_SSC_Configure( AT91C_BASE_SSC, (49152000), (2*16*48000), 0, 0, AT91C_I2S_ASY_MASTER_TX_SETTING(16, 2), AT91C_I2S_ASY_TX_FRAME_SETTING(16, 2)); //(dla zegara 49,152MHz; fsample = fclk/1024 = 48kHz i jeszcze 0WS)
            config_TC0(24000); //i ustawienie TC0,by generował przerwanie co 500ms dla takiej częstotliwości zegara
          }
          else { //w przeciwnym razie ustawienie zegara mikrokontrolera dla domyślnej wartości fsample=44,1kHz
                 AT91F_CKGR_CfgPLLReg(AT91C_BASE_CKGR, AT91C_CKGR_USBDIV_0 | (48 << 16) | AT91C_CKGR_OUT_0 | AT91C_CKGR_PLLCOUNT | 20); //mikrokontroler taktowany jest zegarem (18,432 * (48+1) / 20) = 45,1584MHz; fsample=44,1kHz
                 while (! (AT91F_PMC_IsStatusSet(AT91C_BASE_PMC, AT91C_PMC_LOCK))){}; //w pętli while odczekanie na ustabilizowanie się pętli PLL
                 AT91F_SSC_Configure( AT91C_BASE_SSC, (45158400), (2*16*sampling_freq), 0, 0, AT91C_I2S_ASY_MASTER_TX_SETTING(16, 2), AT91C_I2S_ASY_TX_FRAME_SETTING(16, 2)); //(dla zegara 45,1584MHz; fsample=44,1kHz)
                 config_TC0(22050); //i ustawienie TC0,by generował przerwanie co 500ms dla takiej częstotliwości zegara
               }
          AT91F_SSC_EnableTx( AT91C_BASE_SSC);  //Enable the TX transmitter
          out_Samples = mp3FrameInfo.outputSamps;
          AT91F_SSC_SendFrame( AT91C_BASE_SSC, (char*)outBuf, out_Samples, (char*)outBuf, out_Samples); //wysłanie do portu SSC poprzez kanał DMA danych dla przetwornika D/A i wypełnienie drugiego bufora DMA
          configured = true;  //interfejs SSC jest już skonfigurowany
        }

 *AT91C_RTTC_RTMR = 1; //ustawienie preskalera RTT w celu przyspieszenia przyjmowania przerwań od RTT, by uzyskać szybsze wystawianie znaków na LCD

config_RTT();  //ponowne ustawienie preskalera RTT,by przerwanie od niego następowało co 1ms przy fclk=32768Hz

      wyswietl_tekst_na_LCD(0xC0,"Time:  ");
      wyswietl_tekst_na_LCD(0xCB,";total:");
      wyswietl_tekst_na_LCD(0xD8,";bitrate=");
      wyswietl_tekst_na_LCD(0xE4,"kbs");

      offset = MP3FindSyncWord(readPtr, (sizeof(tablica_bajtow_danych) - (readPtr - tablica_bajtow_danych))); //poszukiwanie nagłówka ramki MP3 w tablica_bajtow_danych począwszy od elementu wskazywanego wskaźnikiem readPtr; przeszukiwane będzie jeszcze (sizeof(tablica_bajtow_danych) - (readPtr - tablica_bajtow_danych)) pozostałych bajtów w tablica_bajtow_danych
      if (offset < 0) //gdy została przepatrzona cała tablica_bajtow_danych i nie udało się w niej znaleść nagłówka ramki MP3, to poniżej
      {
        bytesLeft = bytesLeft - (sizeof(tablica_bajtow_danych) - (readPtr - tablica_bajtow_danych)); //zmniejszenie bytesLeft (liczby pozostałych bajtów pliku) o liczbę przepatrzonych już bajtów, wśród których nie było nagłówka ramki MP3
        result = read_sector_from_current_or_next_cluster(numer_wpisu_poczatku_listy);  //wypełnienie tablicy_bajtow_danych nową porcją danych z karty SD   
        if ((result == 0xFF) | (result == 0)) //gdy koniec pliku (wtedy result == 0xFF) lub błąd odczytu karty (wtedy result == 0), to:
             outOfData = 1; //ustawienie zmiennej outOfData, by można było wyjść z pętli dekodującej MP3
        else readPtr = tablica_bajtow_danych;  //w przeciwnym razie nowe dane z karty SD są poprawnie odczytane i teraz wskaźnik readPtr wskazuje pierwszy element tablicy_bajtow_danych z nowymi danymi
        continue;  //i skok do instrukcji while (!outOfData) - końca pętli dekodującej ramki MP3
      }

    if (! (tablica_wpisow.is_directory)) //gdy wybrany wpis jest wpisem pliku,to
     {
       ... //tu realizacja pętli odtwarzającej wszystkie pliki w aktywnym podkatalogu począwszy od wybranego pliku aż do końca listy plików w aktywnym podkatalogu 
     }  
     else //w przeciwnym razie wybrany z listy wpis jest wpisem podkatalogu i wtedy:
     {
       unsigned int first_cluster_number = tablica_wpisow.first_cluster_nbr;  //numer pierwszego klastra zajętego przez wybrany z listy podkatalog
       liczba_wpisow = read_dir(rodzaj_karty, first_cluster_number, start_address); //odczytanie zawartości wybranego z listy podkatalogu, w zmiennej liczba_wpisow jest ilość plików i podkatalogów w wybranym podkatalogu
       if (liczba_wpisow == 0xFF) //gdy liczba_wpisow == 0xFF, to jest to błąd odczytu zawartości karty w powyższej funkcji read_dir, i wtedy:
       {
         AT91F_SPI_Disable( AT91C_BASE_SPI);  //wyłączenie SPI
         init_LCD(); //inicjacja wyświetlacza LCD         
         wyswietl_tekst_na_LCD(0x80,"No SDcard!Insert");  //tekst wyświetlany w pierwszym wierszu LCD
         wyswietl_tekst_na_LCD(0xC0,"SD with FAT32"); //tekst wyświetlany w drugim wierszu LCD
         play_mp3_sound(sound1, size1); //odtworzenie MP3 z dźwiękiem ostrzegawczym o źle włożonej karcie SD
         play_mp3_sound(sound1, size1); //odtworzenie MP3 z dźwiękiem ostrzegawczym o źle włożonej karcie SD
         wait(2000);
         shutdown_player(240); //wyłączenie odtwarzacza     
       }
       numer_wpisu_poczatku_listy = list_files_directories(1/*=numer_wpisu_poczatku_listy*/, liczba_wpisow, 2, 16); //teraz wylistowanie na LCD 2*16 nazw plików i podkatalogów począwszy od pierwszej pozycji zapamiętanej w zmiennej tablica_wpisow
                                                           // w zmiennej numer_wpisu_poczatku_listy jest numer wpisu pliku lub podkatalogu, którego nazwa jest wyswietlana w pierwszym wierszu LCD
       opoznienie_przewijania = 0; //wyzerowanie tej zmiennej,by rozpocząć przewijanie w poziomie długich nazw plików i podkatalogów podczas wyświetlania listy dopiero po osiągnięciu przez tą zmienną wartości czasu opóźnienia
     }//koniec warunku if (! (tablica_wpisow.is_directory)) spr.czy wybrany wpis jest wpisem pliku

   if ((! (AT91F_PIO_GetInput(AT91C_BASE_PIOA) & SW2)) & (~ play_key_pressed)) //gdy dopiero teraz naciśnięty przycisk SW2 - Play (czyli jeszcze w tym miejscu play_key_pressed == false),to:
   { 
     current_time = 0; //wyzerowanie bieżącego czasu, by prawidłowo ściemnić podświetlanie LCD podczas odtwarzania pliku
     dimming_LCD_backlight(current_time, aktualizacja_LCD_odtwarzanie); //ściemnienie podświetlania LCD po 10sek od momentu wejścia do podkatalogu
     play_key_pressed = true; //to zmiana stanu play_key_pressed.Potrzebne,by uniknąć sytuacji naprzemiennego wchodzenia do podkatalogu i wychodzenia z niego w przypadku przytrzymania przycisku Play
     wait(300);//i odczekanie na zanik drgań zestyków przycisku Play
     start_address = play_file_enter_subdir(numer_wpisu_poczatku_listy); //wywołanie funkcji play_file_enter_subdir,która zwraca adres pierwszego sektora karty SD zajętego przez wybrany plik lub podkatalog
     if (! (tablica_wpisow.is_directory)) //gdy wybrany wpis jest wpisem pliku,to
     {
       unsigned char licznik_odtworzonych_plikow = numer_wpisu_poczatku_listy; //zainicjowanie licznika odtworzonych plików
       do //poniższa pętla odtwarza wszystkie pliki począwszy od wybranego wartością numer_wpisu_poczatku_listy pliku do końca listy plików
       {
         play_mp3_file(licznik_odtworzonych_plikow); //wywołanie funkcji odtwarzającej wybrany plik.Funkcja ta korzysta również ze zmiennej start_address

  result = read_sector(start_address + licznik, rodzaj_karty); //odczytanie nowych danych z pierwszego sektora karty SD należącego do klastra zajętego przez odtwarzany plik
  readPtr = tablica_bajtow_danych;  //teraz wskaźnik readPtr wskazuje pierwszy element tablicy_bajtow_danych

    if (((readPtr - tablica_bajtow_danych) + 4) > sizeof(tablica_bajtow_danych)) //spr.czy nagłówki kolejnych ramek mieszczą się w całości w tablicy_bajtow_danych. Gdy nie mieszczą
    {  //się,to oznacza, że fragment kolejnego nagłówka ramki MP3 jest na końcu tablicy_bajtow_danych i wtedy poniżej
...
    }
        else //w przeciwnym razie nagłówki kolejnych ramek MP3 mieszczą się w całości w tablicy_bajtow_danych i wtedy
    {
      offset = MP3FindSyncWord(readPtr, (sizeof(tablica_bajtow_danych) - (readPtr - tablica_bajtow_danych))); //poszukiwanie nagłówka ramki MP3 w tablica_bajtow_danych począwszy od elementu wskazywanego wskaźnikiem readPtr; przeszukiwane będzie jeszcze (sizeof(tablica_bajtow_danych) - (readPtr - tablica_bajtow_danych)) pozostałych bajtów w tablica_bajtow_danych

      if (offset < 0) //gdy została przepatrzona cała tablica_bajtow_danych i nie udało się w niej znaleść nagłówka ramki MP3, to poniżej
      {
        bytesLeft = bytesLeft - (sizeof(tablica_bajtow_danych) - (readPtr - tablica_bajtow_danych)); //zmniejszenie bytesLeft (liczby pozostałych bajtów pliku) o liczbę przepatrzonych już bajtów, wśród których nie było nagłówka ramki MP3
        result = read_sector_from_current_or_next_cluster(numer_wpisu_poczatku_listy);  //wypełnienie tablicy_bajtow_danych nową porcją danych z karty SD   
        if ((result == 0xFF) | (result == 0)) //gdy koniec pliku (wtedy result == 0xFF) lub błąd odczytu karty (wtedy result == 0), to:
             outOfData = 1; //ustawienie zmiennej outOfData, by można było wyjść z pętli dekodującej MP3
        else readPtr = tablica_bajtow_danych;  //w przeciwnym razie nowe dane z karty SD są poprawnie odczytane i teraz wskaźnik readPtr wskazuje pierwszy element tablicy_bajtow_danych z nowymi danymi
        continue;  //i skok do instrukcji while (!outOfData) - końca pętli dekodującej ramki MP3
      }
      readPtr += offset;  //w przeciwnym razie udało się znaleść nagłówek i wtedy zwiększenie readPtr, tak, by wskazywał na pierwszy bajt tego nagłówka 
      err = MP3GetNextFrameInfo(hMP3Decoder, &mp3FrameInfo, readPtr);  //pobranie informacji o ramce MP3 na podstawie znalezionego wyżej nagłówka
      if (err) {  //gdy nie uda się pobrać informacji (to nie był nagłówek, wtedy err <> 0)
                 readPtr = readPtr + 1; //to zwiększenie o 1 wskaźnika readPtr, by dalsze poszukiwanie nowego nagłówka rozpoczęło się od następnego bajtu po tym mylnie zakwalifikowanym jako początek nagłówka ramki MP3
                 continue; //i skok do instrukcji while (!outOfData) - końca pętli dekodującej ramki MP3
               }
      //w przeciwnym razie udało się pobrać informacje o kolejnej ramce MP3 i wtedy poniżej obliczenie rozmiaru tej ramki (rozmiar ramki zależy również od wersji MPEG)

if (! (AT91F_PIO_GetInput(AT91C_BASE_PIOA) & AT91C_PIO_PA30))
   {    //gdy PA30 = L, to odtwarzacz NIE jest dołączony do portu USB w kompie i wtedy:
     liczba_wpisow = read_dir(rodzaj_karty, opis_partycji.first_cluster_num, opis_partycji.first_data_sector_address); //odczytanie zawartości głównego katalogu na karcie SD, w zmiennej liczba_wpisow jest ilość plików i podkatalogów w katalogu głównym na karcie SD
     if (liczba_wpisow == 0) //gdy na karcie SD nie ma plików i podkatalogów (karta była formatowana), to:
     { 
       AT91F_SPI_Disable( AT91C_BASE_SPI);  //wyłączenie SPI
       wyswietl_tekst_na_LCD(0x80,"No directories/");  //tekst wyświetlany w pierwszym wierszu LCD
       wyswietl_tekst_na_LCD(0xC0,"files on SD Card"); //tekst wyświetlany w drugim wierszu LCD
       play_mp3_sound(sound1, size1); //odtworzenie MP3 z dźwiękiem ostrzegawczym o źle włożonej karcie SD
       play_mp3_sound(sound1, size1); //odtworzenie MP3 z dźwiękiem ostrzegawczym o źle włożonej karcie SD
       wait(2000);
       shutdown_player(240); //wyłączenie odtwarzacza     
     }
     numer_wpisu_poczatku_listy = list_files_directories(1/*=numer_wpisu_poczatku_listy*/, liczba_wpisow, 2, 16); //teraz wylistowanie na LCD 2*16 nazw plików i podkatalogów począwszy od pierwszej pozycji zapamiętanej w zmiennej tablica_wpisow. W zmiennej numer_wpisu_poczatku_listy jest numer wpisu pliku lub podkatalogu, którego nazwa jest wyswietlana w pierwszym wierszu LCD
   }

switch (tablica_bajtow_danych[11 + (32 * licznik_paczek)]) //sprawdzanie  11.bajtu w każdej paczce
{
  case 0x08:  //analizowana paczka zawiera nazwę partycji
    if (power_on_or_USB_connected) //wyświetlenie tej nazwy tylko po właczeniu zasilania lub po odłączeniu USB
    {
      configure_LCD(0x01); //wyczyszczenie wyświetlacza LCD (Display Clear)
      wait(3);
      for (licznik_petli = 0; licznik_petli < 11; licznik_petli++) //pętla wystawiająca znaki etykiety karty SD na wyświetlaczu LCD
      {
        if (tablica_bajtow_danych[licznik_petli + (32 * licznik_paczek)] < 0x80) //spr,czy jest to 7-bitowy kod ASCII. Gdy tak,to: 
           wyswietl_znak_ASCII_na_LCD(0x82 + licznik_petli, tablica_bajtow_danych[licznik_petli + (32 * licznik_paczek)]);//wystawianie na LCD 7-bit ASCII znaków etykiety karty SD
        else //w przeciwnym razie może być to kod polskiej litery (w 8-bit ASCII) i wtedy
        { 
          if (tablica_bajtow_danych[licznik_petli + (32 * licznik_paczek)] == 0xE5) break; //gdy jest skasowana etykieta karty SD, to opuszczenie pętli wystawiającej znaki etykiety karty na LCD
          else //w przeciwnym razie jest to kod polskiej litery i poniżej wyświetlenie tej polskiej litery na LCD
          {
            wyswietl_polski_znak_na_LCD(0x82 + licznik_petli, (adres_CGRAM << 3), tablica_bajtow_danych[licznik_petli + (32 * licznik_paczek)]);
            adres_CGRAM++;  //zwiększenie adresu CGRAM, bo jedna polska litera została już wyświetlona
          }
        }
      }
      if (tablica_bajtow_danych[licznik_petli + (32 * licznik_paczek)] != 0xE5) //gdy jest obecna etykieta karty SD, to wyświetlenie jej przez 2 sekundy
      {                                                                         //razem z wyświetleniem napięcia baterii
        wyswietl_tekst_na_LCD(0xC0,"Vbatt=");
        AT91F_ADC_StartConversion(AT91C_BASE_ADC);  //uruchomienie przetwornika A/C
        while (! (AT91C_BASE_ADC->ADC_SR & AT91C_ADC_EOC5));  //i po odczekaniu, gdy Vbat jest już przetworzone na wartość cyfrową
        converted_Vbat = AT91F_ADC_GetConvertedDataCH5(AT91C_BASE_ADC); //to odczytanie cyfrowej wartości Vbat
        Vbat = ((2500 * converted_Vbat) + 14625) / 1979; //obliczenie rzeczywistego napięcia baterii na podstawie wartości odczytanej z ADC
        itoa(Vbat,txt_Vbat,10); //konwersja liczbowej wartości napięcia baterii na postać łańcuchową
        if (Vbat < 100) //gdy napięcie baterii < 1V to odpowiedni format łańcucha txt_Vbat, tak, by poprawnie były wyświetlane wartości napięcia < 1V
        {                
          txt_Vbat[2] = txt_Vbat[1];//przeniesienie części ułamkowej napięcia baterii na odpowiednie pozycje w łańcuchu txt_Vbat
          txt_Vbat[1] = txt_Vbat[0];
          txt_Vbat[0] = 0x30; //przed przecinkiem będzie wyświetlana liczba 0
        }
        wyswietl_znak_ASCII_na_LCD(0xC6,txt_Vbat[0]);
        wyswietl_znak_ASCII_na_LCD(0xC7,',');
        wyswietl_znak_ASCII_na_LCD(0xC8,txt_Vbat[1]);
        wyswietl_znak_ASCII_na_LCD(0xC9,txt_Vbat[2]);
        wyswietl_znak_ASCII_na_LCD(0xCA,'V');
        wait(2000);  
      }
    }
    break;

if (tablica_bajtow_danych[licznik_petli + (32 * licznik_paczek)] == 0xE5) break; //gdy jest skasowana etykieta karty SD, to opuszczenie pętli wystawiającej znaki etykiety karty na LCD

    if (! ( (AT91F_PIO_GetInput(AT91C_BASE_PIOA) & SW1) | ((AT91F_PIO_GetInput(AT91C_BASE_PIOA) & SW0) << 1) ))//gdy naciśnięte naraz przyciski SW1 i SW0(=L) (wtedy odczyt napięcia baterii),to:
    {
      if (! (show_battery_voltage)) //gdy wyświetlenie napięcia jest pierwszy raz po naciśnięciu przycisków SW1 i SW0
      {
        aktualizacja_LCD_odtwarzanie = false; //to wyzerowanie zmiennych aktualizacja_LCD_odtwarzanie i aktualizacja_LCD_glosnosc w celu 
        aktualizacja_LCD_glosnosc = false; //prawidłowego działania funkcji volume_control po zwolnieniu jednego z tych przycisków lub dwóch naraz
        configure_LCD(0x01); //wyczyszczenie wyświetlacza LCD (Display Clear)
        wait(15);
        configure_LCD(0x02); //dana konfigurująca wyświetlacz LCD(Cursor/Display Home) 
        wait(15);
        wyswietl_tekst_na_LCD(0x81,"Ubattery=");
        wyswietl_znak_ASCII_na_LCD(0x8B,',');
        wyswietl_znak_ASCII_na_LCD(0x8E,'V');
      }
      show_battery_voltage = true;  //i ustawienie zmiennej show_battery_voltage, by przytrzymanie naciśniętych przycisków SW1 i SW0 nie powtarzało powyższych instrukcji
      AT91F_ADC_StartConversion(AT91C_BASE_ADC);  //uruchomienie przetwornika A/C
      while (! (AT91C_BASE_ADC->ADC_SR & AT91C_ADC_EOC5));  //i po odczekaniu, gdy Vbat jest już przetworzone na wartość cyfrową
      converted_Vbat = AT91F_ADC_GetConvertedDataCH5(AT91C_BASE_ADC); //to odczytanie cyfrowej wartości Vbat
      Vbat = ((2500 * converted_Vbat) + 14625) / 1979; //obliczenie rzeczywistego napięcia baterii na podstawie wartości odczytanej z ADC
      itoa(Vbat,txt_Vbat,10); //konwersja liczbowej wartości napięcia baterii na postać łańcuchową
      wyswietl_znak_ASCII_na_LCD(0x8A,txt_Vbat[0]); //i wyświetlenie tej wartości na LCD
      wyswietl_znak_ASCII_na_LCD(0x8C,txt_Vbat[1]);
      wyswietl_znak_ASCII_na_LCD(0x8D,txt_Vbat[2]);
    }
    else //w przeciwnym razie :
    {
      show_battery_voltage = false; //wyzerowanie zmiennej show_battery_voltage,by prawidłowo pokazać wartość napięcia baterii gdy znów będą naciśnięte przyciski SW0 i SW1
      volume_control(numer_wpisu_poczatku_listy); //oraz wywoływana jesrt procedura nastawiająca głośność odtwarzania
    }

switch (packet_CBW.CBWCB_Table[0])  //pole Operation Code w ramce SCSI

 case 0x2F: //komenda Verify 
                nbr_of_data = 0;
                Send_CSW_packet(0, packet_CBW.CBWCB_Table[0], nbr_of_data); //teraz wypełnienie zmiennej tablica_bajtow_danych danymi z pakietu CSW i wysłanie jej do hosta
                break;

MP3GetLastFrameInfo(hMP3Decoder, &mp3FrameInfo); //uzyskanie informacji o zdekodowanej ramce MP3
if (! (configured)) // gdy była to dopiero pierwsza poprawnie zdekodowana ramka, to najpierw przed wysłaniem danych do portu SSC
{ //skonfigurowanie interfejsu SSC
  sampling_freq = mp3FrameInfo.samprate;
  if (sampling_freq == 48000) 
  { //gdy częstotliwość próbkowania odczytana z odtwarzanego pliku = 48kHz, to poniżej ustawienie clk ARM-a na wartość 73,728MHz i ustawienie cyklu 1WS
    *AT91C_RTTC_RTMR = 3; //ustawienie preskalera RTT w celu przyspieszenia przyjmowania przerwań od RTT, by uzyskać szybsze wystawianie znaków na LCD
    AT91F_MC_EFC_CfgModeReg( AT91C_BASE_MC, (AT91C_MC_FMCN | AT91C_MC_FWS_1FWS)); //ustawienie 1 cyklu WaitState
    AT91F_CKGR_CfgPLLReg(AT91C_BASE_CKGR, AT91C_CKGR_USBDIV_0 | (3 << 16) | AT91C_CKGR_OUT_0 | AT91C_CKGR_PLLCOUNT | 1); //mikrokontroler taktowany jest zegarem (18,432 * (3+1) / 1) = 73,728MHz
    while (! (AT91F_PMC_IsStatusSet(AT91C_BASE_PMC, AT91C_PMC_LOCK))){}; //w pętli while odczekanie na ustabilizowanie się pętli PLL
    AT91F_SSC_Configure( AT91C_BASE_SSC, (73728000), (2*16*48000), 0, 0, AT91C_I2S_ASY_MASTER_TX_SETTING(16, 2), AT91C_I2S_ASY_TX_FRAME_SETTING(16, 2)); //(dla zegara 73,728MHz; fsample =  48kHz)
    config_TC0(36000); //i ustawienie TC0,by generował przerwanie co 500ms dla częstotliwości zegara = 73,728MHz 
    *AT91C_TC1_RC = 8; //oraz ustawienie TC1 tak,by prawidłowo działał interfejs L3 w UDA1330 dla częstotliwości zegara = 73,728MHz
  }
  else  //w przeciwnym razie ustawienie zegara mikrokontrolera dla domyślnej wartości fsample=44,1kHz
  {
    AT91F_CKGR_CfgPLLReg(AT91C_BASE_CKGR, AT91C_CKGR_USBDIV_0 | (48 << 16) | AT91C_CKGR_OUT_0 | AT91C_CKGR_PLLCOUNT | 20); //mikrokontroler taktowany jest zegarem (18,432 * (48+1) / 20) = 45,1584MHz; fsample=44,1kHz
    while (! (AT91F_PMC_IsStatusSet(AT91C_BASE_PMC, AT91C_PMC_LOCK))){}; //w pętli while odczekanie na ustabilizowanie się pętli PLL
    AT91F_SSC_Configure( AT91C_BASE_SSC, (45158400), (2*16*sampling_freq), 0, 0, AT91C_I2S_ASY_MASTER_TX_SETTING(16, 2), AT91C_I2S_ASY_TX_FRAME_SETTING(16, 2)); //(dla zegara 45,1584MHz; fsample=44,1kHz)
    config_TC0(22050); //i ustawienie TC0,by generował przerwanie co 500ms dla częstotliwości zegara = 45,1584MHz
    *AT91C_TC1_RC = 4; //oraz ustawienie TC1 tak,by prawidłowo działał interfejs L3 w UDA1330 dla częstotliwości zegara = 45,1584MHz
  }
  AT91F_SSC_EnableTx( AT91C_BASE_SSC);  //Enable the TX transmitter
  out_Samples = mp3FrameInfo.outputSamps;
  AT91F_SSC_SendFrame( AT91C_BASE_SSC, (char*)outBuf, out_Samples, (char*)outBuf, out_Samples); //wysłanie do portu SSC poprzez kanał DMA danych dla przetwornika D/A i wypełnienie drugiego bufora DMA
  AT91F_PMC_EnablePeriphClock( AT91C_BASE_PMC, 1 << AT91C_ID_SSC ) ;  //enable the clock of the SSC
  configured = true;  //interfejs SSC jest już skonfigurowany
}

/*funkcja wkładająca do tablicy bajtów danych w odpowiedzi na komendę Read odczytany blok danych z karty SD i później 
wysyłająca tą tablicę do hosta USB.
Argumentami funkcji sa:
 1. ilość bloków, które mają być odesłane hostowi
 2. adres bloku, od którego zaczyna się odczyt karty SD
Zwracaną wartością jest liczba bajtów odesłanych hostowi w odpowiedzi na komendę Read = ilość bloków * 512 */
unsigned int Read_From_Card(unsigned short length, unsigned int LBA)
{
  signed short licznik_blokow = length;
  if (length == 0) AT91F_USB_SendZlp(pCDC, AT91C_EP_IN); //wysłanie Zero Length Packet do hosta USB, gdy ten wysłał komendę Read,ale bez podania ilości bloków do odczytu
  else
  {
    if (length > 1) //gdy ilość bloków,które mają być odczytane z karty, jest większa od 1 
    {       //to poniżej realizacja odczytu wielu bloków z karty SD
        unsigned char *dane_z_karty_SD = malloc(32768); //zarezerwowanie w heap obszaru na tablicę o rozmiarze 32kB przechowującą dane odczytywane z karty
        // if (dane_z_karty_SD == 0) goto SINGLE_BLOCK; //(gdyby było potrzebne)gdy nie udało się zaalokować RAM-u na tablicę dane_z_karty_SD,to odczyt pojedynczych bloków
        AT91F_SPI_CfgCs( AT91C_BASE_SPI, SD_Card_Access, (0x0 << 24) | (0x0 << 16) | (AT91C_SPI_SCBR - 0xFC00) | AT91C_SPI_BITS_8 | !(AT91C_SPI_CSAAT) | !(AT91C_SPI_NCPHA) | (AT91C_SPI_CPOL) ); //ust. SPI mode 3 (AT91C_SPI_CPOL) | !(AT91C_SPI_NCPHA), 8 bitów danych, bez opóźnień między zegarem i danymi, bez opóźnień pomiędzy poszczególnymi danymi(potrzebne dla kart SD), częstotliwość zegara = MainCLK / (0xFF - 0xFC) 
        while (licznik_blokow > 0) //gdy jeszcze są do odczytania dane z karty, wtedy licznik_blokow > 0 i poniższa pętla się wykonuje
        {
          AT91F_MC_EFC_CfgModeReg( AT91C_BASE_MC, (AT91C_MC_FMCN | AT91C_MC_FWS_3FWS)); //ustawienie 3 cykli Wait States przed odczytem dnych z karty (zegar MainCLK = 96MHz)
          read_multiple_sectors(dane_z_karty_SD, (licznik_blokow > 0x40 ? 0x40 : licznik_blokow), LBA, (CSD.CSD_Structure ? true : false));//odczytanie (64 lub licznik_blokow) bloków począwszy od adresu w LBA; gdy zwykła karta SD (CSD_Structure = 0),to false, w przeciwnym razie true  
          AT91F_MC_EFC_CfgModeReg( AT91C_BASE_MC, (AT91C_MC_FMCN | AT91C_MC_FWS_1FWS)); //ustawienie 1 cyklu WS przed wysłaniem odczytanych danych do kompa przez USB
          AT91F_UDP_Write(&pCDC, dane_z_karty_SD, (512 * (licznik_blokow > 0x40 ? 0x40 : licznik_blokow))); //wysłanie wypełnionej tablicy dane_z_karty_SD do hosta USB
          LBA = LBA + (licznik_blokow > 0x40 ? 0x40 : licznik_blokow); //zwiększenie adresu LBA o liczbę odczytanych już bloków
          licznik_blokow = licznik_blokow - 0x40; //i zmniejszenie licznika bloków; gdy ta wartość będzie <= 0, t.zn. już wszystkie bloki zostały odczytane z karty
        }
        free(dane_z_karty_SD);
    }
    else 
//SINGLE_BLOCK:  
    {
       AT91F_SPI_CfgCs( AT91C_BASE_SPI, SD_Card_Access, (0x0 << 24) | (0x0 << 16) | (AT91C_SPI_SCBR - 0xFC00) | AT91C_SPI_BITS_8 | !(AT91C_SPI_CSAAT) | !(AT91C_SPI_NCPHA) | (AT91C_SPI_CPOL) ); //ust. SPI mode 3 (AT91C_SPI_CPOL) | !(AT91C_SPI_NCPHA), 8 bitów danych, bez opóźnień między zegarem i danymi, bez opóźnień pomiędzy poszczególnymi danymi(potrzebne dla kart SD), częstotliwość zegara = MainCLK / (0xFF - 0xFC) 
       while (licznik_blokow) //w przeciwnym razie odczyt pojedynczych bloków z karty 
       {
         AT91F_MC_EFC_CfgModeReg( AT91C_BASE_MC, (AT91C_MC_FMCN | AT91C_MC_FWS_3FWS)); //ustawienie 3 cykli Wait States przed odczytem dnych z karty (zegar MainCLK = 96MHz)
         read_sector(LBA,(CSD.CSD_Structure ? true : false));//odczytanie bloku o adresie w LBA; gdy zwykła karta SD (CSD_Structure = 0),to false, w przeciwnym razie true
         AT91F_MC_EFC_CfgModeReg( AT91C_BASE_MC, (AT91C_MC_FMCN | AT91C_MC_FWS_1FWS)); //ustawienie 1 cyklu WS przed wysłaniem odczytanych danych do kompa przez USB
         AT91F_UDP_Write(&pCDC, tablica_bajtow_danych, 512); //wysłanie wypełnionej tablicy bajtów danych do hosta USB
         LBA++; //adres następnego bloku do odczytu
         licznik_blokow--; //zmniejszenie o 1 licznika bloków, bo jeden odczytany blok został już wysłany do hosta USB
       }
    }
  }
  return (length * pow(2, CSD.Block_Length));
}



/*funkcja odczytująca bloki danych z hosta USB i zapisująca odczytane bloki na kartę SD
Argumentami funkcji sa:
 1. ilość bloków, które mają być odebrane od hosta
 2. adres bloku, od którego zaczyna się zapis danych na kartę SD
Zwracaną wartością jest liczba bajtów odebranych od hosta w odpowiedzi na komendę Write = ilość bloków * 512 */
unsigned int Write_To_Card(unsigned short length, unsigned int LBA)
{ 
  signed short liczba_pozostalych_blokow = length; //liczba pozostałych bloków, które muszą jeszcze być zapisane na kartę SD
  unsigned char *dane_na_karte_SD = malloc(32768); //zarezerwowanie w heap obszaru na tablicę o rozmiarze 32kB przechowującą dane przeznaczone do zapisu na kartę SD
  AT91F_SPI_CfgCs( AT91C_BASE_SPI, SD_Card_Access, (0x0 << 24) | (0x0 << 16) | (AT91C_SPI_SCBR - 0xFB00) | AT91C_SPI_BITS_8 | !(AT91C_SPI_CSAAT) | !(AT91C_SPI_NCPHA) | (AT91C_SPI_CPOL) ); //ust. SPI mode 3 (AT91C_SPI_CPOL) | !(AT91C_SPI_NCPHA), 8 bitów danych, bez opóźnień między zegarem i danymi, bez opóźnień pomiędzy poszczególnymi danymi(potrzebne dla kart SD), częstotliwość zegara = MainCLK / (0xFF - 0xFB)
    while (liczba_pozostalych_blokow > 0) //gdy jeszcze są do zapisania dane na kartę, wtedy liczba_pozostalych_blokow > 0 i poniższa pętla się wykonuje
    {
      AT91F_UDP_Read(&pCDC, dane_na_karte_SD, (512 * (liczba_pozostalych_blokow > 0x40 ? 0x40 : liczba_pozostalych_blokow))); //wypełnienie tablicy dane_na_karte_SD danymi odebranymi z hosta USB
      AT91F_MC_EFC_CfgModeReg( AT91C_BASE_MC, (AT91C_MC_FMCN | AT91C_MC_FWS_2FWS)); //ustawienie 2 cykli Wait States przed zapisem danych na kartę (zegar MainCLK = 96MHz)
      write_multiple_sectors(dane_na_karte_SD, (liczba_pozostalych_blokow > 0x40 ? 0x40 : liczba_pozostalych_blokow), LBA, (CSD.CSD_Structure ? true : false));//zapis na kartę (liczba_pozostalych_blokow) bloków począwszy od adresu w LBA; gdy zwykła karta SD (CSD_Structure = 0),to false, w przeciwnym razie true  
      AT91F_MC_EFC_CfgModeReg( AT91C_BASE_MC, (AT91C_MC_FMCN | AT91C_MC_FWS_1FWS)); //ustawienie 1 cyklu WS przed przesłaniem przez USB danych z kompa do zapisu na kartę
      LBA = LBA + (liczba_pozostalych_blokow > 0x40 ? 0x40 : liczba_pozostalych_blokow); //zwiększenie adresu LBA o liczbę zapisanych już bloków
      liczba_pozostalych_blokow = liczba_pozostalych_blokow - 0x40; //i zmniejszenie liczba_pozostalych_blokow; gdy ta wartość będzie <= 0, t.zn. już wszystkie bloki zostały zapisane na kartę
    }
    free(dane_na_karte_SD);
    return (length * pow(2, CSD.Block_Length));
}

      
attempt = 0;
do  //w poniższej pętli do...while oczekiwanie na pojawienie się pierwszego bajtu <> 0xFF poprzedzającego 512-bajtową paczkę danych. 
{    //Gdy są same 0xFF, to karta SD jeszcze nie wystawiła danych po wysłaniu odpowiedzi i wtedy poniższa pętla ciągle się wykonuje
   AT91F_SPI_PutChar(AT91C_BASE_SPI, 0xFF, SD_Card_Access); //wystawianie 0xFF na MOSI, by utrzymać aktywność CLK
   odebrany_bajt = AT91F_SPI_GetChar( AT91C_BASE_SPI);  //odczytywanie dalszych bajtów danych z karty 
   if ( !(AT91F_PIO_GetInput(AT91C_BASE_PIOA) & AT91C_PIO_PA30)) //gdy NIE jest dołączone USB,to
   {
     attempt++;
     if (attempt > 3500) return read_write_OK = false; //gdy liczba prób odczytania danych z karty > 3500, to wyjście ze zwrotem wartości read_write_OK = false
   }
}
while (odebrany_bajt == 0xFF);  //ta pętla wykonuje się tak długo, jak długo odebrany_bajt == 0xFF

  result = read_multiple_sectors(tablica_bajtow_danych, 2, start_address + licznik, rodzaj_karty); //odczytanie nowych danych z 2 pierwszych sektorów karty SD należących do klastra zajętego przez odtwarzany plik
  licznik = licznik + 2; //zwiększenie licznika odczytanych sektorów, bo powyżej zostały już odczytane 2 sektory; 

(1) fclk = 4 * mnożnik_UDA1330 * fsample

(2) fclk / 4 = mnożnik_UDA1330 * fsample

(3) mnożnik_UDA1330 * fsample = fsysclk UDA1330

(4) mnożnik_UDA1330 = 87859200 / (4 * 44100) ~= 498

unsigned char Vbat_not_converted = true;
wait_counter++; //zwiększenie o 1 zmiennej wait_counter przed wejściem w poniższą pętlę
while (! (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_ENDTX)) //odczekanie w pętli, aż wszystkie poprzednie dane z portu SSC pójdą do przetwornika D/A
{
  if (Vbat_not_converted) //podczas oczekiwania w tej pętli:
  {
     wait_counter--; //i zmniejszenie o 1 tej zmiennej podczas jednokrotnego wykonania tej pętli. W efekcie ,gdy mikrokontroler dostarcza dane do DAC w sposób ciągły (bez przerw),to ta zmienna == 0
     AT91F_ADC_StartConversion (AT91C_BASE_ADC);  //uruchomienie przetwornika A/C
     while (! (AT91C_BASE_ADC->ADC_SR & AT91C_ADC_EOC5));  //i po odczekaniu, gdy Vbat jest już przetworzone na wartość cyfrową
     converted_Vbat = AT91F_ADC_GetConvertedDataCH5 (AT91C_BASE_ADC); //to odczytanie cyfrowej wartości Vbat
     Vbat_not_converted = false; //i odp.ustawienie zmiennej Vbat_not_converted, by podczas dalszego wykonywania się pętli while (! (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_ENDTX)) już nie przetwarzać Vbat
  }
}
if ((wait_counter > 2) & (clock_selector < 2)) //gdy mikrokontoler 2 razy nie zdąży dostarczyć danych dla DAC dla fclk mikrokontrolera wybranej zmienną clock_selector(przyczyną najczęściej zbyt długi odczyt z karty) i gdy clock_selector nie osiągnął jeszcze max wartości (==2)
{
   SSC_configured = false; //to ustawienie zmiennej SSC_configured = false, by móc ponownie skonfigurować zegar mikrokontrolera przy następnym obiegu pętli dekodującej MP3
   clock_selector++; //i zwiększenie clock_selector, by wybrać większą częstotliwość fclk mikrokontrolera. Zwiększanie tej zmiennej trwa tak długo, aż clock_selector == 2
}

       
if (! (SSC_configured)) // gdy była to dopiero pierwsza poprawnie zdekodowana ramka lub wystąpiła zmiana wartości clock_selector, to najpierw przed wysłaniem danych do portu SSC
{ //skonfigurowanie interfejsu SSC
   sampling_freq = mp3FrameInfo.samprate;
   switch (sampling_freq)
   {
       ...
   }
   AT91F_SSC_EnableTx( AT91C_BASE_SSC);  //Enable the TX transmitter
   out_Samples = mp3FrameInfo.outputSamps;
   AT91F_SSC_SendFrame( AT91C_BASE_SSC, (char*)outBuf, out_Samples, (char*)outBuf, out_Samples); //wysłanie do portu SSC poprzez kanał DMA danych dla przetwornika D/A i wypełnienie drugiego bufora DMA
   AT91F_PMC_EnablePeriphClock( AT91C_BASE_PMC, 1 << AT91C_ID_SSC ) ;  //enable the clock of the SSC
   SSC_configured = true;  //interfejs SSC jest już skonfigurowany
   wait_counter = 0; //i wyzerowanie zmiennej wait_counter po wyborze zegara mikrokontrolera
}