W tym poście chcę dodatkowo podłączyć kartę SD korzystając z bibliotek Atmela, a informacje o karcie SD będą wyświetlane poprzez port szeregowy emulowany przez interfejs USB procesora.
Ważną sprawą jest fakt, że ASF (Atmel Software Fundation) to gotowe sterowniki, komponenty, usługi i funkcje realizujące obsługę portów IO, interfejsów komunikacyjnych, usług i procedur do wykorzystania w naszym kodzie.
Czasem dzięki kilku liniom kodu i odpowiednim definicjom można uzyskać naprawdę spektakularne efekty.
Poniżej obrazek ze strony Atmela pokazujący strukturę ASF,
W naszym projekcie będziemy korzystali z następujących komponentów ASF:
- „GPIO service” do zdefiniowania trybu pracy portów procesora
- „SD/MMC stack component” do komunikacji z kartą SD
- „SD/MMC memory Access komponent” zawierający funkcję odczytu i zapisu danych na/z karty
- „USB Device (service) CDC_STDIO” – do obsługi USB w trybie emulacji portu szeregowego przechwytującego STDIN/STDOUT
Użyte w projekcie komponenty ASF w oknie ASF Wizard powinny wyglądać TAK
Po dodaniu komponentów czas na konfigurację plików nagłówkowych.
Tak jak poprzednio konfigurujemy pliki conf_clock.h oraz conf_usb.h
Plik /config/conf_clock.h definiuje parametry taktowania procesora.
Modyfikujemy w nim trzy sekcjie:
1. zmieniamy parametr CONFIG_SYSCLK_SOURCE z domyślnego 2MHz na 32Mhz
[syntax=c]//#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_RC2MHZ
#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_RC32MHZ[/syntax]
2. zmieniamy parametr CONFIG_SYSCLK_PSADIV z domyślnego SYSCLK_PSADIV_1 na SYSCLK_PSADIV_2
[syntax=c]/* Fbus = Fsys / (2 ^ BUS_div) */
#define CONFIG_SYSCLK_PSADIV SYSCLK_PSADIV_2
#define CONFIG_SYSCLK_PSBCDIV SYSCLK_PSBCDIV_1_1[/syntax]
3. usuwamy komentarz w liniach zawierających CONFIG_OSC_RC32_CAL i CONFIG_OSC_AUTOCAL_RC32MHZ_REF_OSC
[syntax=c]#define CONFIG_USBCLK_SOURCE USBCLK_SRC_RCOSC
#define CONFIG_OSC_RC32_CAL 48000000UL
#define CONFIG_OSC_AUTOCAL_RC32MHZ_REF_OSC OSC_ID_USBSOF[/syntax]
Teraz zajmijmy się plikiem /config/conf_usb.h
W nim znajdzmy definicję funkcji wywoływanych po aktywacji portu usb
Musimy odnaleźć w nim definicje UDI_CDC_ENABLE_EXT, UDI_CDC_DISABLE_EXT
i zamienić na poniższe ...
[syntax=c]//! Interface callback definition
//#define UDI_CDC_ENABLE_EXT(port) true
//#define UDI_CDC_DISABLE_EXT(port)
#define UDI_CDC_ENABLE_EXT(port) stdio_usb_enable()
extern bool stdio_usb_enable(void);
#define UDI_CDC_DISABLE_EXT(port) stdio_usb_disable()
extern void stdio_usb_disable(void);[/syntax]
Linie te są odpowiedzialne za podłączenie/odłączenie STDIO w momencie gdy jest aktywowany/deaktywowany port USB z obsługą urządzenia typu Communication Device Class.
Przyda się jeszcze zakomentować poniższą linie znajdującą się gdzieś na początku pliku....
[syntax=c]#warning You must refill the following definitions with a correct values[/syntax]
Nowością będzie definicja pliku conf_board.h.
W pliku tym definiujemy połączenia procesora do komponentów zewnętrznych.
W tym przypadku będą te definicje podłączenia karty SD oraz przycisku sprzętowego FLIP podłączonego do portu E5 procesora.
Jeśli nie mamy przełącznika WRITE_PROTECT to go nie definiujemy, poniżej jest on zakomentowany ponieważ u mnie nie występuje.
Zawartość mojego pliku conf_board.h wygląda tak:
[syntax=c]#ifndef CONF_BOARD_H
#define CONF_BOARD_H
//definicja przycisku FLIP
#define FLIP_GPIO_PORT&PORTE
#define FLIP_GPIO_PINPIN5_bm
#define FLIP_NOT_PRESSED(PORTE.IN & PIN5_bm) != 0
//definicja sposobu podłączenia karty SD/MMC
#define CONF_BOARD_SD_MMC_SPI
#define SD_MMC_SPI_MEM_CNT1
#define SD_MMC_SPI &SPIC
#define SD_MMC_SPI_SCK IOPORT_CREATE_PIN(PORTC,7)
#define SD_MMC_SPI_MISO IOPORT_CREATE_PIN(PORTC,6)
#define SD_MMC_SPI_MOSI IOPORT_CREATE_PIN(PORTC,5)
#define SD_MMC_SPI_0_CS IOPORT_CREATE_PIN(PORTC,4)
#define SD_MMC_0_CD_GPIO IOPORT_CREATE_PIN(PORTE, 0)
#define SD_MMC_0_CD_DETECT_VALUE 0
/*
#define SD_MMC_0_WP_GPIO IOPORT_CREATE_PIN(PORTE, 3)
#define SD_MMC_0_WP_DETECT_VALUE 0
*/
#endif // CONF_BOARD_H[/syntax]
Ponieważ mój zestaw nie jest żadną z płyt uruchomieniowo/deweloperskich Atmela, wieć muszę jeszsze do pliku
/ASF/common/boards/user_board/init.c dopisać zawartość procedury board_init, która inicjuje komponenty zewnętrzne i porty procesora do współpracy z nimi.
Jak widać ja musiałem tylko konfigurować porty IO do współpracy z kartą SD oraz pin E5 do którego jest podłączony microswitch [FLIP].
[syntax=c]void board_init(void)
{
/* This function is meant to contain board-specific initialization code
* for, e.g., the I/O pins. The initialization can rely on application-
* specific board configuration, found in conf_board.h.
*/
#if ((defined SD_MMC_0_MEM) && (SD_MMC_0_MEM == ENABLE)) || ((defined SD_MMC_1_MEM) && (SD_MMC_1_MEM == ENABLE))
ioport_configure_port_pin(&PORTE, PIN0_bm, IOPORT_PULL_UP | IOPORT_DIR_INPUT);//CARD DETECT
ioport_configure_port_pin(&PORTC, PIN4_bm, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT); //CS
ioport_configure_port_pin(&PORTC, PIN6_bm, IOPORT_DIR_INPUT);//MISO
ioport_configure_port_pin(&PORTC, PIN5_bm, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT);//MOSI
ioport_configure_port_pin(&PORTC, PIN7_bm, IOPORT_INIT_HIGH | IOPORT_DIR_OUTPUT);//SCK
sd_mmc_init();
#endif
//FLIP button
ioport_configure_port_pin(FLIP_GPIO_PORT, FLIP_GPIO_PIN, IOPORT_PULL_UP | IOPORT_DIR_INPUT);
}[/syntax]
Skoro jest już tyle... należy zająć się programem głównym...
Po uruchomieniu procesora program czeka za naciśnięcie przycisku podłączonego do portu E5 (zwieramy pin procesora do masy),
daje nam to czas na otwarcie okienka terminala portu szeregowego (u mnie COM5).
Po naciśnięciu przycisku FLIP program działa w pętli badając status karty i wyświetlając informacje o niej.
Zmienna status przechowuje informacje o aktualnym statusie karty SD.
Zmienna port to numer portu ( możliwe jest zdefiniowanie i podłączenie kilku kart SD i wybór pomiędzy nimi za pomocą sygnału CD, użyjemy wtedy SD_MMC_0_CD_GPIO, SD_MMC_1_CD_GPIO itd. w pliku conf_board.h )
Cała reszta to użycie funkcji i definicji które są już w ASF.
A tak wygląda program
[syntax=c]#include <asf.h>
static void main_display_info_card(uint8_t slot)
{
printf("Card information:\n\r");
printf(" type: ");
switch (sd_mmc_get_type(slot)) {
case CARD_TYPE_SD | CARD_TYPE_HC:
printf("SDHC");
break;
case CARD_TYPE_SD:
printf("SD");
break;
case CARD_TYPE_MMC | CARD_TYPE_HC:
printf("MMC High Density");
break;
case CARD_TYPE_MMC:
printf("MMC");
break;
case CARD_TYPE_SDIO:
printf("SDIO\n\r");
return;
case CARD_TYPE_SD_COMBO:
printf("SD COMBO");
break;
case CARD_TYPE_UNKNOWN:
default:
printf("Unknown\n\r");
return;
}
printf("\n\r");
printf(" size: %d MB\n\r", (uint16_t)(sd_mmc_get_capacity(slot)/1024));
printf(" write protect status: ");
if (sd_mmc_is_write_protected(slot)) { printf("ON\n\r"); } else {printf("OFF\n\r");}
}
int main (void)
{
Ctrl_status status;
uint8_t slot = 0;
sysclk_init();//konfiguracja zegara
irq_initialize_vectors();//inicjacja wektorów przerwań (jeśli używamy)
cpu_irq_enable();//włączenie przerwań
board_init();//inicjacja płytki - tu powinno się inicjować porty IO
sleepmgr_init();//optionalny moduł ospowiedzialny za oszczedzanie energii i uśpienie
stdio_usb_init();//inicjacja obsługi portu USB
//czekamy na nacisniecie przycisku FLIP (port E5)
while (FLIP_NOT_PRESSED) {};
//no to dalej
printf("\n\r-- SD/MMC/SDIO Card Example\n\r");
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
while(1) {
printf("Please plug an SD, MMC or SDIO card in slot #%i.\n\r",slot);
/* Wait card present and ready */
do {
status = sd_mmc_test_unit_ready(slot);
if (CTRL_FAIL == status) {
printf("Card install FAIL\n\r");
printf("Please unplug and re-plug the card.\n\r");
while (CTRL_NO_PRESENT != sd_mmc_check(slot)) {
}
}
} while (CTRL_GOOD != status);
// Display basic card information
main_display_info_card(slot);
printf("Please unplug and re-plug the card.\n\r");
while (CTRL_NO_PRESENT != sd_mmc_check(slot)) {};
}
}[/syntax]
Działający program wygląda tak jak poniżej, jest to przykład dla dwóch różnych kart SD.
I to by było na tyle ... w następnym "odcinku" dodamy do projektu bibliotekę FatFS ( jej Atmelowską wersję )
i spróbujemy coś odczytać i zapisać.
Statystyki: Napisane przez radek_w — 23 kwi 2016, o 19:20
]]>