Spajamo SD kartice na abr. Spojimo SD memorijsku karticu na STM32 preko SPI
Prikazali smo sliku na zaslonu s SD kartice, ali neke su točke u njoj propuštene, prva - povezivanje same kartice, druga - uzet je u obzir samo dio funkcija knjižnice Petit FatFs Pogledajmo pobliže ove točke.
Komunikacija s karticom moguća je putem jednog od dva sučelja, SPI ili SD.
Moram reći da SD sučelje može raditi u jednobitnom i četverobitnom načinu rada.
Shema za spajanje kartice preko SPI je standardna i izgleda ovako, neiskorišteni pinovi kartice moraju biti spojeni na napajanje pomoću otpornika od 10K.
Ali u amaterskim dizajnima, pull-up otpornici se često zanemaruju, pojednostavljujući dijagram povezivanja.
Treba napomenuti da kada je spojena preko SPI-a, kartica je vrlo zahtjevna za napon napajanja i mali pad napona napajanja dovodi do neoperativnosti kartice, to je testirano na osobno iskustvo, Nemam što reći o SD sučelju, nisam ga još isprobao. Sve je ovo napisano za napajanje potrebno je ugraditi kondenzatore. Što se tiče induktora, on mora biti naznačen za struju do 100 mA, ali ga nije potrebno instalirati.
Gore prikazani dijagrami pokazuju da je za rad kartice potrebno 3,3 volta, odnosno u vodovima za prijenos podataka napon ne smije prelaziti raspon od 0 - 3,3 volta, a ovdje se postavlja pitanje, što ako se MC napaja s 5 volti?
Odgovor je jednostavan, trebate uskladiti podatkovne linije, a to se može učiniti pomoću konvencionalnog otporničkog razdjelnika.
Dijagram pokazuje da se MISO linija ne mora podudarati jer se podaci prenose preko te linije s kartice na MK.
Zapravo, malo ljudi spaja karticu izravno na MK, puno je prikladnije spojiti konektor kartice na MK ili kupiti štit s konektorom i svim potrebnim kabelskim snopom.
Shvatili smo vezu, sada pogledajmo kako koristiti knjižnicu Petit FatFs, koji je dizajniran za 8-bitne mikrokontrolere s malom veličinom memorije.
Biblioteka se sastoji od 5 datoteka:
cijeli broj.h- datoteka zaglavlja koja opisuje glavne vrste podataka.
diskio.h- datoteka zaglavlja koja deklarira prototipove funkcija niske razine za rad s diskom i statusne kodove koje vraćaju.
diskio.c- u ovu datoteku treba implementirati funkcije niske razine, u početku postoje "zaglavci".
pffconf.h- konfiguracijska datoteka.
pff.h- datoteka zaglavlja u kojoj su deklarirani prototipovi funkcija za interakciju s datotečnim sustavom diska.
pff.c- datoteka sadrži implementacije funkcija za interakciju s datotečnim sustavom diska.
Vidi se da je za rad knjižnice potrebno implementirati funkcije niske razine. Ali ako govorimo o AVR ili PIC, za njih na web mjestu možete preuzeti primjer rada s bibliotekom koja sadrži datoteku mmc, u njemu su već implementirane funkcije niske razine. Također je potrebno postaviti konfiguraciju biblioteke u pff.h datoteku i napisati funkcije potrebne za rad SPI.
Funkcije Petit FatFs.
FRESULT pf_mount (FATFS*)- funkcija montira/demontira disk. Ova se funkcija mora pozvati prije početka rada s diskom, ako pozovete funkciju s null pokazivačem, disk se demontira. Funkciju je moguće pozvati bilo kada.
Mogućnosti
FATFS* fs- pokazivač na objekt tipa FATFS, opis ove strukture nalazi se u datoteci pff.h. Samo trebamo deklarirati varijablu ovog tipa.
Povratne vrijednosti:
FR_OK (0)
FR_NOT_READY- uređaj se nije mogao pokrenuti
FR_DISK_ERR- došlo je do greške prilikom čitanja s diska
FR_NO_FILESYSTEM- pogon nema valjanu FAT particiju
FATFS fs;//deklariranje objekta tipa FATFS //montiranje diska if (pf_mount(&fs) == FR_OK) ( //montiranje diska, rad s njim //montiranje diska pf_mount(NULL); ) else ( //nije uspjelo montiranje diska )
FRESULT pf_open (staza const char*)- funkcija otvara postojeću datoteku. Nakon otvaranja datoteke možete s njom raditi, odnosno čitati iz nje i pisati u nju. Možete raditi s otvorenom datotekom dok se druga datoteka ne otvori. Funkciju je moguće pozvati bilo kada.
Mogućnosti
const char* put- pokazivač na niz koji označava stazu do datoteke. Put mora biti naveden potpuno u odnosu na korijenski direktorij, odvajajući direktorije kosom crtom.
Povratne vrijednosti:
FR_OK (0)- vraća se u slučaju uspješnog izvršenja funkcije
FR_NO_FILE- datoteka nije pronađena
FR_DISK_ERR- greška na disku
FR_NOT_ONABLED- disk nije montiran
FATFS fs;//Deklarisaj objekt tipa FATFS //Mountiraj disk if (pf_mount(&fs) == FR_OK) ( //Otvori datoteku u korijenskom direktoriju if(pf_open("hello.txt") == FR_OK) ( //Učini nešto) //Otvori datoteku u novoj mapi if(pf_open("new/hello.txt") == FR_OK) ( //Učini nešto) //montiranje diska pf_mount(NULL); ) else ( //nije uspjelo montiranje diska)
FRESULT pf_read(void* buff, WORD btr, WORD* br)- funkcija čita navedeni broj bajtova iz datoteke i sprema ih u međuspremnik. Ako je broj pročitanih bajtova manji od navedenog, dosegnut je kraj datoteke.
#define _USE_READ 1
Mogućnosti:
void*buff- pokazivač na međuspremnik u kojem su pohranjeni pročitani podaci
RIJEČ btr- broj bajtova za čitanje
RIJEČ*br- pokazivač na varijablu koja pohranjuje broj pročitanih bajtova.
Povratne vrijednosti:
FR_OK (0)- vraća se u slučaju uspješnog izvršenja funkcije
FR_DISK_ERR- greška na disku
FR_NOT_OTVOREN- datoteka nije otvorena
FR_NOT_ONABLED- disk nije montiran
FATFS fs;//deklarirati objekt tipa FATFS BYTE buff;//spremnik za čitanje datoteke WORD br; // Brojač čitanja bajtova // Montiram disk IF (pf_mount (& fs) == fr_ok) (// Otvorite datoteku koja leži u korijenskom direktoriju if (Pf_open ("Hello.txt") == Fr_ok) (// Čitamo 10 bajtova PF_READ (BUFF, 10, & Br); IF (BR! = 10) (// Ako BR nije jednak 10 // znači da smo dosegli kraj datoteke)))
FRESULT pf_write(const void* buff, WORD btw, WORD* bw)- funkcija vam omogućuje pisanje podataka u otvorenu datoteku. Kako bi funkcija radila u datoteci pffconf.h, morate napisati
#define _USE_WRITE 1
Mogućnosti:
void*buff- pokazivač na međuspremnik koji želimo pisati, nulta vrijednost finalizira pisanje
RIJEČ btw- broj bajtova koje želimo zapisati
RIJEČ*bw- pokazivač na varijablu koja pohranjuje broj bajtova koji se mogu zapisati. Analizom ove varijable možete saznati je li dosegnut kraj datoteke.
Povratne vrijednosti:
FR_OK (0)- vraća se u slučaju uspješnog izvršenja funkcije
FR_DISK_ERR- greška na disku
FR_NOT_OTVOREN- datoteka nije otvorena
FR_NOT_ONABLED- disk nije montiran
Zbog činjenice da je biblioteka dizajnirana za mikrokontrolere s malom količinom memorije, ova funkcija ima niz ograničenja:
- ne možete stvarati nove datoteke i možete samo pisati u postojeće
- veličina datoteke ne može se povećati
- ne mogu ažurirati vremensku oznaku
- operacija pisanja može se pokrenuti/zaustaviti samo na granici sektora
- atribut datoteke samo za čitanje ne može spriječiti pisanje
Da biste razumjeli pretposljednju točku, morate znati da je memorija kartice podijeljena na blokove (sektore) od 512 bajtova i snimanje se može započeti samo od početka sektora. Dakle, ako želimo napisati 1000 bajtova, tada će prvi sektor biti u potpunosti zapisan, au drugi samo 488 bajtova, a preostala 24 bajta bit će popunjena nulama.
Za pisanje u otvorenu datoteku učinite sljedeće:
- postavite pokazivač na granicu sektora, ako nije postavljen na granicu, pokazivač će biti zaokružen na donju granicu sektora
- pozovite funkciju pisanja željeni broj puta
- finalizirati unos pozivanjem funkcije s nultim pokazivačem
Da bismo dali primjer rada funkcije snimanja, potrebno je razmotriti još jednu funkciju.
FRESULT pf_lseek(DWORD pomak)- postavlja pokazivač čitanja/pisanja na otvorena datoteka. Pokazivač možete postaviti s apsolutnim ili relativnim pomakom; za apsolutni pomak morate funkciji proslijediti broj
pf_lseek(5000);
za relativno, proslijedite vrijednost pokazivača na trenutnu poziciju fs.fptr i iznos pomaka
pf_lseek(fs.fptr + 3000);
Kako bi funkcija radila u datoteci pffconf.h, morate napisati
#define _USE_LSEEK 1
Mogućnosti:
DWORD pomak je broj bajtova na koje treba pomaknuti pokazivač.
Povratne vrijednosti:
FR_OK (0)- vraća se u slučaju uspješnog izvršenja funkcije
FR_DISK_ERR- greška na disku
FR_NOT_OTVOREN- datoteka nije otvorena
Možete pisati podatke u datoteku na sljedeći način.
FATFS fs;//deklarirati objekt tipa FATFS BYTE buff;//spremnik za čitanje datoteke WORD br; // Brojač pročitanih bajtova // Montiranje diska IF (pf_mount (& fs) == fr_ok) (// Otvori datoteku koja se nalazi u korijenskom direktoriju if (PF_OPEN ("Hello.txt") == Fr_ok) (/ E (BUFF, 10, & Br); // Završi PF_WRITE (0, 0, & Br)))
Ovdje također ostavljam dio koda koji stvarno radi i koristi sve gore opisane funkcije.
#define F_CPU 8000000UL #define buff_size 10 #include
FRESULT pf_opendir(DIR* dp, const char * staza)- funkcija otvara postojeći direktorij i stvara pokazivač na objekt tipa DIR, koji će se koristiti za dobivanje popisa datoteka u otvorenom direktoriju.
Kako bi funkcija radila u datoteci pffconf.h, morate napisati
#define _USE_DIR 1
Mogućnosti:
DIR *dp- pokazivač na varijablu tipa DIR.
const char *staza- pokazivač na niz koji sadrži put do direktorija, imenici su odvojeni kosom crtom
Povratne vrijednosti:
FR_OK (0)- vraća se u slučaju uspješnog izvršenja funkcije
FR_NO_PATH- nije mogao pronaći put
FR_NOT_READY- Neuspješno pokretanje diska
FR_DISK_ERR- greška na disku
FR_NOT_ONABLED- disk nije montiran
//deklariranje varijabli FATFS fs; DIR dir; //montiraj disk pf_mount(&fs); //otvori direktorij pf_opendir(&dir, "MOJA_MAPA");
FRESULT pf_readdir(DIR* dp, FILINFO* fno)- funkcija vam omogućuje čitanje sadržaja imenika. Da biste to učinili, otvorite direktorij s funkcijom pf_opendir() i pozovite pf_readdir(). Svaki put kad se funkcija pozove, vratit će naziv objekta (mape/datoteke) koji se nalazi u navedenom direktoriju. Kada prođe kroz sve objekte, vratit će nulti niz u elementu polja fno.fname.
Kako bi funkcija radila u datoteci pffconf.h, morate napisati
#define _USE_DIR 1
Mogućnosti:
DIR *dp- pokazivač na varijablu tipa DIR, koja mora biti prethodno deklarirana
FILINFO *fno- pokazivač na varijablu tipa FILINFO, koja mora biti prethodno deklarirana.
Povratne vrijednosti:
FR_OK- uspješno obavljanje funkcije
FR_DISK_ERR- greška na disku
FR_NOT_OTVOREN- imenik nije otvoren
FATFS fs; FRESULT res; FILINFO fno; DIR dir; //montiraj disk pf_mount(&fs); //otvori direktorij res = pf_opendir(&dir, MOJA_MAPA); //pročitaj sadržaj direktorija za(;;)( res = pf_readdir(&dir, &fno); //provjeri je li bilo grešaka tijekom čitanja // i ima li još datoteka u navedenom direktoriju if ((res != FR_OK) || (fno.fname == 0))( break; ) //prikaži na prikladan način fno.fname usart_sendStr(fno.name); usart_sendStr(/r); )
I na kraju, radni projekt ću ostaviti ovdje
Lekcija 33
1. dio
SPI. SD kartica. MAST
Danas ćemo nastaviti našu omiljenu temu o SPI sučelju. Završili smo s ovom sabirnicom za kontrolere Atmega8a i ATTtiny2313. I danas ćemo pokušati spojiti memorijsku karticu na mikrokontroler preko ove sabirnice pomoću ovog sučelja SD (Secure Digital).
Ova se kartica također može spojiti preko SDIO sučelja, ali budući da takvo sučelje ne podržava hardver našeg kontrolera, nećemo ga doticati u ovoj lekciji. Zanima nas vrsta autobusne veze SPI, budući da već imamo dobro akumulirano znanje o ovoj temi, kao i hardversku podršku u kontroleru koji programiramo.
Ipak, vidjet ćemo pinout nogu kartice za obje vrste.
Pa, budući da nas zanima drugi tip, bavit ćemo se njime.
I tu se zapravo nema što razumjeti. Sve su nam te kratice poznate. Ovdje su sve standardne noge SPI sučelja i ovdje nema ništa suvišno.
Sada o karti općenito. Ova kartica nam omogućuje pohranjivanje podataka, vrsta memorije joj je FLASH, koja je u usporedbi s memorijom tipa EEPROM također trajna, odnosno kada se isključi struja podaci ne nestaju nigdje, već ostaju pohranjeni. Također, ova memorija ima razlike, s njima ćemo se upoznati u procesu programiranja. Jedna od glavnih razlika je da ne možemo upisati jedan bajt u ovu memoriju, kao u EEPROM memoriji. Teoretski, naravno da možemo, ali tu će biti zapisane samo jedinice iz našeg bajta ili samo nule, ovisno o vrsti FLASH-a - NOR ili NAND. To jest, prije nego što zapišete bajt, morate ga obrisati, a zbog organizacije ove memorije, možemo brisati samo u blokovima, pa stoga i pisati samo u blokovima. Ali postoji najveća razlika u odnosu na EEPROM - to je cijena. To je višestruko jeftinije, čak ponekad i za red veličine za jednu pohranjenu jedinicu informacija (po megabajtu, po gigabajtu). Stoga FLASH memorija obično ima mnogo veću količinu informacija.
Postoje 4 vrste SD-a, ali to ćemo proučiti malo kasnije.
Spojimo ovu karticu dok smo u proteusu
Ovdje je sve jednostavno. Zapravo ne baš tako. Treba više otpornika
Ovi otpornici su potrebni kako bi se osigurale odgovarajuće razine, budući da se kartica napaja s 3,3 volta. Općenito, prema tehničkoj dokumentaciji, od 2,7 do 3,6 volti.
Također, to nije naznačeno u proteusu, ali zapravo ćemo našu karticu napajati iz zasebnog napajanja instaliranjem mikro kruga koji pretvara 5 volti u 3,3 volta.
Umjesto toga, nećemo ništa instalirati, već ćemo koristiti gotov modul u kojem je sve već instalirano.
Također imamo povezani zaslon, kao u proširenju funkcionalnosti knjižnice zaslona.
Ovako to izgleda u praksi
Ovako izgleda modul s držačem
Takav modul možete pronaći posvuda, košta peni. Modul koji se povezuje preko SDIO košta više. Također vidimo da je na modulu već instaliran mikro krug za smanjenje napona na 3,3 volta. I spajamo napajanje samo na kontakt od 5 volti, a ne spajamo ništa na 3.3
Također, na modulu su instalirani svi razdjelnici za razine, odnosno ovaj modul je dizajniran posebno za spajanje na 5-voltne uređaje.
I iskopao sam flash karticu za testove od 32 megabajta, točno megabajt a ne gigabajt
Ova flash kartica je donirana uz neku vrstu fotoaparata i ona će nam najbolje odgovarati za naše testove, barem nećemo misliti da imamo ovaj ili onaj kvar zbog previše memorije na kartici.
Kod je također preuzet iz prošle lekcije zajedno s bibliotekom za prikaz, budući da ćemo vrlo aktivno koristiti funkciju koju smo stvorili u prošloj lekciji, samo je naravno kreiran novi projekt i nazvan u skladu s tim MYSD_SPI.
Izbrišite nepotrebne retke, u main() ćemo imati samo ovo
intglavni( poništiti)
nepotpisanintja;
Port_ini();
LCD_ini(); //inicijalizirati prikaz
clearlcd(); //očistite zaslon
setpos(0,0);
str_lcd( "Niz 1");
setpos(2,1);
str_lcd( "string2");
setpos(4,2);
str_lcd( "niz 3");
setpos(6,3);
str_lcd( "niz 4");
Odgoda_ms(2000);
// za (i=0;i<=22;i++) {str80_lcd(buffer2+i*20);_delay_ms(1000);}
Dok(1)
Budući da nećemo prikazati tekst znak po znak, moći će se snaći s tipom char u varijabli
nepotpisanchar ja;
Sada još jedna nijansa.
Da bismo mogli raditi sa SD karticom u Proteusu, nije nam dovoljno dodati držač uz samu karticu, već moramo priložiti i slikovnu datoteku flash kartice u njezinim svojstvima.
Nije ga teško stvoriti. Jedan od načina je da ga izradite pomoću programa WinImage.
U njemu standardno stvaramo novu datoteku pomoću stavke izbornika Datoteka -\u003e Novo. Odaberite posljednju stavku u dijaloškom okviru i kliknite "U redu"
Za test u Proteusu, veličina od 4 megabajta nam je sasvim dovoljna, pa ćemo u sljedećem dijalogu promijeniti polje s brojem sektora, a također odabrati format FAT12 / 16, jer s 32-bitnim datotečnim sustavom nešto drugačije specifičnosti rada, a također kliknite "OK"
Općenito, naravno, možemo ostaviti i FAT32, budući da još ne radimo s datotečnim sustavom, ali u daljnjim dijelovima lekcije radit ćemo s datotečnim sustavom i radit ćemo s 12/16.
Zatim spremamo kreiranu datoteku pomoću stavke izbornika Datoteka -> Spremi kao. I spremamo ga u folder gdje imamo spremljeni proteus projekt. Imenujte datoteku i kliknite "Spremi"
Također, tada ćete morati provjeriti da nismo dobili ovu datoteku s atributom "samo za čitanje", a nakon toga je već možemo spojiti u proteus. Bit će potrebno ručno unijeti naziv datoteke, jer proteus zahtijeva neku vrstu vlastitog formata i naša datoteka jednostavno neće biti vidljiva
Ne treba nam nikakva staza, jer imamo datoteku u mapi projekta. Pritisnemo "OK".
Ne trebamo inicijalizirati sabirnicu, budući da ćemo imati softverski SPI, ne rade sve flash kartice ispravno s hardverskim flash karticama, tada nećemo morati koristiti nikakve registre. Naravno, onaj hardverski je bolji, ali da biste temeljito razumjeli rad protokola, morate raditi i sa softverom, odnosno trzati nožicama portova. Općenito, gledajući dijagram, može se činiti da imamo sve u hardveru, budući da sam odabrao upravo takve noge, to je zato što sam to izabrao tako da će kasnije, jednog dana, možda netko pokušati raditi s hardverskom implementacijom sabirnice.
Dodajte makro zamjene za priključke
#uključi"glavni.h"
#definiratiMOSI3
#definiratiMISO4
#definiratiSCK5
#definiratiSS2
Dodajmo kod za inicijalizaciju nogu u funkciju inicijalizacije porta
poništitiport_ini( poništiti)
PORTD=0x00;
DDRD=0xFF;
PORTB|=(1<< SS)|(1<< MISO)|(1<< MOSI);
DDRB|=(1<< SS)|(1<< MOSI)|(1<< SCK);
Ostavljamo MISO nogu na ulazu, jer su prema zadanim postavkama svi bitovi u registru nula, i jednostavno je ne diramo. Također odmah uključujemo visoku razinu u MOSI i SS i podižemo otpornik na MISO.
Napišimo funkciju za prijenos bajta preko SPI sabirnice
poništitiSPI_SendByte( nepotpisancharbajt)
{
}
Dodajte varijablu za petlju i samu petlju
poništitiSPI_SendByte( nepotpisancharbajt)
nepotpisancharja;
za( ja=0; ja<8; ja++) // pomicanje po bitovima bajta
{
}
Mislim da je razumljivo zašto brojimo do 8, budući da prenosimo točno 8 bitova.
Pa, počnimo ih krišom prolaziti.
Provjerimo najprije krajnji lijevi bit, odabiremo ga iz cijelog bajta maskiranjem, pa ako imamo jednak 1, postavimo ga na 1 na MOSI sabirnici, a ako je 0, onda ne diramo sabirnicu
za( ja=0; ja<8; ja++) // pomicanje po bitovima bajta
Dobar dan svima! Danas ćemo razgovarati o spajanje SD memorijske kartice na STM32 mikrokontroler.
Čini se da kontroleri STM32F10x imaju dosta memorije, zašto postoji dodatna, ali ovaj dojam je varljiv) Na primjer, moramo prikazati nekoliko različitih slika na zaslonu - format 320 * 240 - to jest 76800 piksela, od kojih svaka odgovara čak 2 bajta. Dakle, dobivamo oko 150 kB po slici. A to je puno prema standardima mikrokontrolera, a nije činjenica da se u njegovu Flash memoriju mogu ubaciti dvije različite slike. Ili trebamo pohraniti velike količine informacija, podatke s nekog senzora, na primjer. Štoviše, tako da su ti podaci dostupni i nakon što je napajanje isključeno. Ovdje je vanjska memorija korisna. I odlično rješenje SD memorijska kartica ili MMC. Usput, u ovom članku ćemo provesti eksperimente na mikro SD karticu.
Prvo, nekoliko riječi o samoj memorijskoj kartici, odnosno o njenom pinoutu. Cijela stvar izgleda ovako:
Dakle, što imamo ovdje? Pa odmah se vidi da ona ima čak osam zaključaka. Dodjela pinova je sljedeća (s lijeva na desno):
Stupac SPI Mode nam daje naslutiti da je u interakciji s mikrokontrolerom pomoću SPI sučelja. ALI! Mi ćemo krenuti drugim putem 😉 Stvar je u tome što STM32 ima već gotov periferni modul za rad s memorijskim karticama, a zove se SDIO.
Općenito, interakcija s memorijskim karticama sastoji se u prijenosu određenih naredbi na njih. Neke naredbe zahtijevaju argument, neke ne. Naredbe se nalaze u službenoj dokumentaciji za pojedinu karticu. Dakle, ugrađeni SDIO modul omogućuje znatno pojednostavljenje procesa prijenosa naredbi, pa čak i procesa rada s vanjskim memorijskim karticama. Na primjer, ovdje je registar SDIO_CMD- tu jednostavno jednostavno zapišemo šifru naredbe koju želimo prenijeti na karticu. Ili ovdje je registar stanja SDIO_STA- postoje čak 24 zastavice za svaki kih, odnosno za veliki broj događaja.
Usput, STM također zadovoljava dobrom dokumentacijom za cijelu stvar. Ovdje je, primjerice, detaljan opis inicijalizacije za SD memorijsku karticu (slično je sve opisano i za ostale vrste kartica):
Pa, zapravo, vrijeme je da prijeđemo na praktični primjer. Istražimo Standardnu perifernu biblioteku.
U datoteci stm32f10x_sdio.h tradicionalno nalazimo strukture za sve vrste postavki - to jest, odabir izvora taktnog signala, frekvencije SDIO kontrolera i podešavanje broja bajtova koji se prenose. Tamo je sve tako velikodušno komentirano da ne želim ni ponavljati zasebno)) Samo pogledajte:
| typedef struct ( uint32_t SDIO_ClockEdge; /* Određuje prijelaz takta na kojem se vrši snimanje bitova. Ovaj parametar može biti vrijednost @ref SDIO_Clock_Edge */ uint32_tSDIO_ClockBypass; /* Određuje je li premosnica razdjelnika SDIO takta omogućena ili onemogućena. Ovaj parametar može biti vrijednost @ref SDIO_Clock_Bypass */ uint32_tSDIO_ClockPowerSave; /* Određuje je li izlaz SDIO takta omogućen ili onemogućen kada je sabirnica u stanju mirovanja. Ovaj parametar može biti vrijednost @ref SDIO_Clock_Power_Save */ uint32_tSDIO_BusWide; /* Određuje širinu SDIO sabirnice. Ovaj parametar može biti vrijednost @ref SDIO_Bus_Wide */ uint32_t SDIO_HardwareFlowControl; /* Određuje je li SDIO hardverska kontrola toka omogućena ili onemogućena. Ovaj parametar može biti vrijednost @ref SDIO_Hardware_Flow_Control */ uint8_tSDIO_ClockDiv; /* Određuje taktnu frekvenciju SDIO kontrolera. Ovaj parametar može biti vrijednost između 0x00 i 0xFF. */) SDIO_InitTypeDef; typedef struct ( uint32_t SDIO_Argument; /* Određuje argument SDIO naredbe koji se šalje kartici kao dio naredbene poruke. Ako naredba sadrži argument, mora se učitati u ovaj registar prije nego što se naredba upiše u registar naredbi */ uint32_t SDIO_CmdIndex; /* Određuje indeks SDIO naredbe. Mora biti manji od 0x40. */ uint32_t SDIO_odgovor; /* Specificira tip SDIO odgovora. Ovaj parametar može biti vrijednost @ref SDIO_Response_Type */ uint32_tSDIO_Čekaj; /* Određuje je li SDIO zahtjev za čekanje na prekid omogućen ili onemogućen. Ovaj parametar može biti vrijednost @ref SDIO_Wait_Interrupt_State */ uint32_t SDIO_CPSM; /* Određuje je li SDIO Command path state machine (CPSM) omogućen ili onemogućen. Ovaj parametar može biti vrijednost @ref SDIO_CPSM_State */) SDIO_CmdInitTypeDef; typedef struct ( uint32_t SDIO_DataTimeOut; /* Određuje razdoblje vremenskog ograničenja podataka u razdobljima takta sabirnice kartice. */ uint32_tSDIO_Duljina podataka; /* Određuje broj bajtova podataka za prijenos. */ uint32_tSDIO_DataBlockSize; /* Određuje veličinu bloka podataka za prijenos bloka. Ovaj parametar može biti vrijednost @ref SDIO_Data_Block_Size */ uint32_tSDIO_TransferDir; /* Određuje smjer prijenosa podataka, bilo da je prijenos čitanje ili pisanje. Ovaj parametar može biti vrijednost @ref SDIO_Transfer_Direction */ uint32_tSDIO_TransferMode; /* Određuje je li prijenos podataka u stream ili block modu. Ovaj parametar može biti vrijednost @ref SDIO_Transfer_Type */ uint32_t SDIO_DPSM; /* Određuje je li SDIO Data path state machine (DPSM) omogućen ili onemogućen. Ovaj parametar može biti vrijednost @ref SDIO_DPSM_State */) SDIO_DataInitTypeDef; |
Obratite pažnju na to kako SPL implementira prijenos naredbi na memorijsku karticu. Za te je svrhe izdvojena posebna građevina. SDIO_CmdInitTypeDef. U polju SDIO_CmdIndex unesite kod naredbe u polje SDIO_Argument- argument naredbe, ispunite i preostala polja. Ostalo je još nekako ugurati ove podatke u mikro SD karticu 😉 A za to smo pripremili funkciju:
SDIO_SendCommand (SDIO_CmdInitTypeDef *SDIO_CmdInitStruct)
Kao argument, prosljeđujemo mu istu strukturu koju smo stvorili. Postoji funkcija za pisanje podataka - SDIO_WriteData(uint32_tData). Nakon poziva ove funkcije podaci će biti u posebno dizajniranom registru - SDIO_FIFO.
Ovako se odvija rad sa SDIO modulom u STM32F10x)
Sada napokon prijeđimo na praksu. Opet ću raditi s pločom Mini STM32, jer su dobri Kinezi bili zbunjeni instaliranjem utora za mikro SD memorijsku karticu na nju. Evo dijagrama spajanja konektora kartice na mikrokontroler: 
Da bismo napisali program, koristit ćemo gotov primjer za Keil - odande ćemo ukrasti dvije datoteke u kojima je implementirano nešto poput upravljačkog programa za rad s karticama - to su datoteke sdcard.c I sdcard.h Napravimo novi projekt, povežemo te datoteke tamo, a osim toga, naravno, CMSIS i SPL datoteke. Ovdje je gotov projekt, u kojem je sve već dodano - ostaje samo napisati kod za glavnu () funkciju)
Datoteka sdcard.c implementira sve vrste funkcija za rad s memorijskom karticom, sada ih samo moramo koristiti 😉 Napišimo kod! Na primjer, upišimo 512 bajtova testnih podataka na micro SD, a zatim ih pokušajmo pročitati:
| // Povezivanje potrebnih datoteka#include "stm32f10x.h" #include "sdcard.h" /*******************************************************************/ // Nizovi ulaznih i izlaznih podataka i varijabla za pohranu podataka// o našoj mapi uint8_t writeBuffer[ 512 ] ; uint8_t readBuffer[ 512 ] ; SD_CardInfo SDCardInfo; /*******************************************************************/ int main() ( // Testni podaci za pisanje za (uint16_t i = 0; i< 512 ; i++ ) { writeBuffer[ i] = i % 256 ; readBuffer[ i] = 0 ; } // Inicijalizacija karte SD_Init() ; // Dobivanje podataka o karti SD_GetCardInfo(& SDCardInfo) ; // Odabir karte i postavljanje načina rada SD_SelectDeselect((uint32_t) (SDCardInfo.RCA<< 16 ) ) ; SD_SetDeviceMode(SD_POLLING_MODE) ; // I na kraju, pisanje i čitanje SD_WriteBlock(0x00, writeBuffer, 512) ; SD_ReadBlock(0x00, readBuffer, 512) ; dok (1) ()) /*******************************************************************/ |
Imajte na umu da SD kartica podržava pisanje u blokovima od 512 bajtova.
Ako pokrenemo program pod debuggerom, vidjet ćemo da pročitani podaci odgovaraju upisanim podacima =) Dakle, eksperiment se može smatrati uspješnim. To je kraj za danas, vidimo se uskoro!
Mihail Russkikh
Dane su kratke informacije o SD karticama, dane su osnove rada SD sabirnice, objašnjen je postupak korištenja stm324xg_eval_sdio_sd drajvera, dizajniranog da pojednostavi komunikaciju STM32 mikrokontrolera sa SD karticama.
Neki ugrađeni sustavi moraju moći pohraniti velike količine informacija. Na primjer, snimači raznih fizikalnih veličina i parametara (struja, napon, temperatura, zemljopisne koordinate) moraju pohraniti očitanja dobivena od senzora na određeni medij, koji se kasnije može ukloniti iz uređaja i spojiti na računalo za pregled podataka u jednostavnom obliku. Kako bi se riješio ovaj problem, čini se da je najočiglednija uporaba USB flash pogona. Oni su široko rasprostranjeni na tržištu i omogućuju pohranjivanje velikih količina informacija. Ali za neke male ugrađene sustave, kompaktnost je najvažnija, a ti pogoni mogu biti preveliki. Osim toga, nisu svi mikrokontroleri opremljeni USB modulom, a dizajner sustava može provesti dosta vremena baveći se USB stogom, što može produljiti vrijeme projekta. U tom smislu, dobra alternativa USB-u je korištenje SD kartica, koje su vrlo kompaktne i omogućuju razmjenu podataka korištenjem zajedničkog SPI sučelja ili namjenskog sučelja za SD kartice.
SD (Secure Digital) memorijske kartice prvenstveno su dizajnirane za korištenje u prijenosnim uređajima. Danas na tržištu postoji veliki broj modela, koje pružaju tvrtke kao što je SanDisc, koji mogu snimati podatke od 8 MB do 2 TB pri brzinama koje ovise o klasi. SD kartice, za razliku od MMC kartica, osim uobičajenog prostora za pohranu podataka, imaju posebno zaštićeno područje koje nije dostupno prosječnom korisniku. Kako bi uređaj mogao čitati podatke snimljene na SD kartici u obliku datoteka, ova kartica mora imati određeni datotečni sustav. Najpoželjniji sustav u ovom slučaju je FAT sustav, budući da je broj ciklusa pisanja/čitanja za SD kartice ograničen, a sustavi poput NTFS-a i ext-a vode se u dnevniku, odnosno uključuju često prozivanje.
Prijenos i prijam podataka vrši se preko SPI sučelja ili preko SD sabirnice. Slika 1 prikazuje dodjelu pinova za različite vrste SD kartica, a tablica 1 prikazuje funkcionalnost ovih pinova.
| Stol 1. | Funkcionalna svrha pinova SD kartice | ||||||||||||||||||||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||||||||||||||||||||
Iako glavni kontroler može komunicirati s karticom koristeći SPI, SD sabirnica još uvijek pruža više opcija i omogućuje vam prijenos informacija većom brzinom zbog prisutnosti četiri podatkovne linije. Stoga ćemo u nastavku detaljnije razmotriti upravo ovu metodu rada sa SD karticom.
Prijenos podataka putem SD sabirnice
Komunikacija sa SD karticom odvija se preko 6 informacijskih linija: 4 podatkovne linije (DAT0, DAT1, DAT2, DAT3), linije za sinkronizaciju (CLK), linije za prijenos naredbi (CMD). Kada je spojen na kontroler, podatkovna linija i linija za naredbe moraju biti priključeni na napajanje, kao što je prikazano na slici 2.
Zapisivanje i čitanje podataka izvodi se blok po blok. Obično se blok sastoji od 512 bajtova. Prijenos podataka i servisnih informacija temelji se na modelu interakcije "naredba-odgovor". Prije slanja ili primanja podataka, glavni kontroler mora poslati odgovarajuću naredbu na CMD liniji. Odgovor bi trebao doći sa SD kartice duž iste linije, nakon čega se može izvršiti potrebna radnja. SD standard podržava prisutnost više podređenih uređaja na sabirnici, u kojem slučaju glavni kontroler može slati naredbe emitiranjem. Naredba ima jasnu strukturu koja se sastoji od 48 bita: 1 početni bit, 1 prijenosni bit (postavljen na 1), 6 bitova za indeks naredbe, 32 bita za argument, 7 bitova za kontrolni zbroj i 1 stop bit. Odgovor može imati istu 48-bitnu strukturu (u ovom slučaju, prijenosni bit je postavljen na 0) ili se sastoji od 136 bitova (tzv. format dugog odgovora): 1 početni bit, 1 prijenosni bit (postavljen na 0), 6 rezerviranih bitova, 127 bitova sadržaja CID (Card Identification Register) ili CSD (Card Specific Data Register) registara i kontrolne sume, 1 stop bit.
Na početku rada s karticom, host kontroler ponovno učitava karticu pomoću naredbi GO_IDLE_STATE(CMD0) I IO_RW_DIRECT (CMD52). Kompletan popis naredbi s opisima nalazi se u (Dodatak A). Nakon ponovnog pokretanja, kartica će vratiti zadane postavke i njezina adresa bit će jednaka RCA = 0x0001. Ako je nekoliko kartica spojeno na glavno računalo, tada pomoću naredbe SET_RELATIVE_ADDR (CMD3) svakoj kartici daje vlastitu adresu. Također, na početku rada provjerava se napon primijenjen na karticu. Napon kartice mora biti unutar strogo utvrđenog raspona od 2,7 do 3,6 V. U tom smislu, glavni upravljač pomoću naredbe SEND_OP_COND (CMD1 ili ACMD41) mora saznati trenutni napon na kartici i prestati raditi s njom ako nije unutar potrebnog raspona. Ovo je opći princip inicijalizacije kartice, za koji se, ovisno o vrsti kartice (MMC, SD, SD I/O), mogu koristiti druge naredbe i dodatni koraci, tako da pri implementaciji sučelja niske razine morate pažljivo pročitati dokumentaciju za karticu i proučiti CMD naredbe.
Tijekom pisanja, host šalje jedan ili više blokova kartici pomoću naredbe WRITE_BLOCK (CMD24) ili WRITE_MULTIPLE_BLOCK (CMD25), dok na kraju svakog bloka host zapisuje kontrolni zbroj. Kartica koja je omogućena za pisanje uvijek će moći primiti blok(ove), ali ako kontrolni zbroj ne odgovara, kartica će prijaviti pogrešku i neće pisati trenutni blok u svoju memoriju, a u slučaju pucanja, sljedeći blokovi će biti zanemareni.
Također možete prenijeti informacije na host, odnosno čitati, u jednom bloku pomoću naredbe READ_SINGLE_BLOCK (CMD17) ili skupina od nekoliko blokova pomoću naredbe READ_MULTIPLE_BLOCK (CMD18). U slučaju burst prijenosa, glavno računalo može prekinuti čitanje u bilo kojem trenutku slanjem naredbe STOP_PRIJENOS (CMD12). Ako tijekom prijenosa nekoliko blokova interni kontroler kartice popravi pogrešku, tada će prestati slati podatke glavnom kontroleru, ali će ostaviti karticu u načinu rada za prijenos podataka. U ovom slučaju, host će morati prisilno završiti čitanje naredbom CMD12, dok će kao odgovor na ovu naredbu kartica javiti grešku čitanja.
Organizacija ispravnog rada SD sabirnice prilično je naporan proces, jer osim gore opisanih općih situacija, potrebno je predvidjeti različite nijanse u ponašanju kartice i implementirati dodatne rukovatelje pogreškama. Stoga bi najracionalnije rješenje bilo korištenje posebnih biblioteka koje programeru omogućuju da ne ulazi u detalje prijenosa podataka na hardverskoj razini i značajno skraćuje vrijeme razvoja. Jedna od tih biblioteka, o kojoj će biti riječi u nastavku, je biblioteka upravljačkog programa. stm324xg_eval_sdio_sd za popularne mikrokontrolere, što vam omogućuje značajno pojednostavljenje rada sa SDIO modulom, dizajniranim za interakciju sa SD karticama.
stm324xg_eval_sdio_sd upravljački program
Ovaj upravljački program je biblioteka funkcija s kojima možete implementirati sučelje visoke razine za komunikaciju sa SD karticom. Upravljački program isporučuje se za rad s pločom za otklanjanje pogrešaka STM324VG (UtilitiesSTM32_EVALSTM3240_41_G_EVAL), ali nakon promjene funkcija koje povezuju ovu biblioteku sa SDIO sučeljem niske razine, može funkcionirati s mnogim mikrokontrolerima obitelji STM32, koji uključuju SDIO modul. Iz prethodne rečenice proizlazi da u projekt treba uključiti datoteke iz standardne biblioteke Standardna periferna knjižnica, koji osiguravaju rad SDIO modula na niskoj razini. Na primjer, za mikrokontrolere serije STM32F4xx, to će biti datoteke stm32f4xx_sdio.c I stm32f4xx_sdio.h.
Prije korištenja funkcija upravljačkog programa, programer mora ovaj upravljački program povezati s hardverom, odnosno konfigurirati linije SDIO modula. Da bi to učinio, mora stvoriti funkcije u glavnoj datoteci svog programa main.c SD_LowLevel_Init() (kako biste omogućili SDIO modul) i SD_LowLevel_DeInit() (za onemogućavanje SDIO modula) u kojem ove linije trebaju biti konfigurirane. Ako programer želi koristiti modul za izravni pristup memoriji za povećanje brzine rada sa SD karticom, tada će također morati stvoriti funkcije SD_LowLevel_DMA_TxConfig() I SD_LowLevel_DMA_RxConfig() odgovoran za prijenos i primanje podataka pomoću PDP modula. Kao primjer inicijalizacije četiri navedene funkcije možemo uzeti kod dostupan u datoteci stm324xg_eval.c iz (UtilitiesSTM32_EVALSTM3240_41_G_EVAL).
Sada pogledajmo glavne funkcije za rad sa SD karticom koje nudi ovaj upravljački program. Kako biste inicijalizirali kartu, trebate pozvati funkciju SD_Init() , koji konfigurira SDIO modul pozivajući se na SD_LowLevel_Init() , provjerava tip SD kartice, dobiva servisne informacije iz CID i CSD registara, postavlja brzinu prijenosa (24 MHz prema zadanim postavkama) i postavlja širinu sabirnice (4 bita). Pomoću funkcija možete pročitati podatke primljene s kartice SD_ReadBlock() (za čitanje jednog bloka) i SD_ReadMultiBlocks() (za čitanje više blokova). Za pisanje podataka na karticu koristite funkcije SD_WriteBlock() (za pisanje jednog bloka) i SD_WriteMultiBlocks() (za pisanje više blokova). Ove funkcije čitanja i pisanja uzimaju tri argumenta: pufer(buffer varijabla u koju treba smjestiti podatke za čitanje i pisanje), adresa(adresa memorijske lokacije SD kartice) i veličina_bloka(uvijek 512 jer ove funkcije rade samo na blokovima koji su dugi 512 bajtova). Za brisanje određenog područja memorije kartice postoji funkcija SD_Erase() . Uzima startaddr i endaddr kao argumente. Prvi specificira adresu memorijske ćelije od koje će započeti brisanje, a drugi specificira adresu ćelije u kojoj će brisanje biti dovršeno.
Prijenos podataka između SDIO modula i memorije mikrokontrolera može se izvesti na uobičajen način preko središnjeg procesora i putem jedinice za izravni pristup memoriji. Da biste odabrali željeni način rada, trebate u datoteci stm324xg_eval_sdio_sd.h otkažite komentar ili redak #define SD_POLLING_MODE(normalan način) ili liniju #define SD_DMA_MODE(PDP način rada). Nakon svake operacije pisanja ili čitanja, morate koristiti ovu funkciju SD_GetStatus() provjerite je li kartica završila trenutnu operaciju i je li spremna za primanje ili slanje novih podataka. Ako ova funkcija vrati SD_TRANSFER_OK, prijenos je uspješno dovršen, SD_TRANSFER_BUSY vraća da je kanal prijenosa zauzet, a SD_TRANSFER_ERROR vraća pogrešku prijenosa. Sve ove vrijednosti definirane su u strukturi SDTransferState, snimljeno u stm324xg_eval_sdio_sd.h. Ukoliko je prijenos informacija izvršen preko PDP bloka, tada je dodatno potrebno provjeriti je li PDP kontroler izvršio sve operacije prijenosa podataka. To se radi pomoću funkcije SD_ReadWaitOperation() . Također je vrijedno napomenuti da prijenos kroz DMA blok završava prekidom, tako da programer mora organizirati poziv funkcije SD_ProcessIRQ() u obrađivaču prekida modula SDIO SDIO_IRQHandler() i poziv funkcije SD_ProcessDMAIRQ() u rukovatelju prekidima DMA2 DMA2_Streamx_IRQHandler() .
Radi boljeg razumijevanja rada drajvera stm324xg_eval_sdio_sd možete koristiti radni primjer iz mape SDIOSDIO_uSDCard(ProjektSTM32F4xx_StdPeriph_ExamplesSDIO). Pomoću ovog testnog programa možete izbrisati određeno područje memorije kartice, pisati podatke na određenu adresu, čitati podatke na istu adresu, a zatim usporediti poslane i primljene informacije. Identitet međuspremnika za prijem i međuspremnik za slanje pokazatelj je da SDIO modul, komunikacijska sabirnica i SD kartica rade normalno.
Stoga možemo reći da su SD kartice dostojni konkurenti USB flash pogonima kada je u pitanju dizajn malih ugrađenih sustava koji zahtijevaju velike količine podataka za pohranu. Podatke možete prenositi s i na karticu pomoću SPI sučelja ili putem SD sabirnice koja je za tu svrhu dizajnirana i omogućuje visoku brzinu prijenosa. Implementacija komunikacije s karticom uvelike je pojednostavljena korištenjem posebnih upravljačkih programa koji olakšavaju rad s hardverom i programerima nude funkcije jednostavne za korištenje. No, nažalost, nijedan operativni sustav, na primjer Windows, neće prihvatiti podatke zapisane nasumičnim redoslijedom, pa će se u sljedećem dijelu raspravljati o tome kako raditi sa SD karticom s FAT datotečnim sustavom.
Popis izvora
SD i microSD kartice mogu značajno proširiti mogućnosti Arduino projekata koji rade s velikim količinama podataka: data logeri, vremenske stanice, pametni kućni sustavi. Arduino ploče opremljene su relativno malom internom memorijom, samo do 4 kilobajta, uključujući i flash memoriju i EEPROM. Ova memorija neće biti dovoljna za upisivanje velikih količina podataka, pogotovo ako se ploča stalno gasi ili gasi. Spajanje Arduino SD kartice kao vanjskog pogona omogućuje vam višestruko povećanje prostora za pohranu bilo koje informacije. Izmjenjivi SD diskovi su jeftini, lako se povezuju i koriste. U članku će se raspravljati o ispravnom povezivanju SD kartice s Arduinom.
Rad sa SD memorijom u arduinu nije osobito težak. Najlakši način je povezati gotov modul i koristiti standardnu biblioteku. Počet ćemo s ovom opcijom.
Korištenje gotovog modula ima razne prednosti. Ovo je prilično jednostavan i praktičan alat za rad s velikim količinama podataka. Ne zahtijeva posebne vještine u povezivanju, svi konektori su potpisani izravno na ploči. Morate platiti za praktičnost, ali trošak modula je relativno nizak, može se lako pronaći po pristupačnim cijenama u ruskim i stranim internetskim trgovinama.
Univerzalni modul je obična ploča na kojoj se nalazi utor za karticu, otpornici i regulator napona. Ima sljedeće tehničke karakteristike:
- Raspon radnog napona 4,5-5 V;
- Podržava SD karticu do 2 GB;
- Struja 80 mA;
- FAT 16 datotečni sustav.
Modul SD kartice implementira takve funkcije kao što su pohranjivanje, čitanje i pisanje informacija na kartici, što je potrebno za normalan rad uređaja temeljenog na mikrokontroleru.
Naravno, jeftini moduli memorijskih kartica također imaju nedostatke. Primjerice, najjeftiniji i najčešći modeli podržavaju samo kartice do 4 GB, a gotovo svi moduli omogućuju pohranjivanje datoteka veličine do dva gigabajta na SD karticu – to je ograničenje FAT datotečnog sustava koji se koristi u većini modela.
Još jedan nedostatak memorijskih kartica je relativno dugo vrijeme snimanja, ali postoje načini za rad s njim, omogućujući vam povećanje brzine. Za to se koristi mehanizam predmemoriranja, kada se podaci najprije akumuliraju u RAM-u, a zatim se odjednom prebacuju na memorijsku karticu.
Arduino ploče za rad sa SD
Za rad sa SD karticom postoji nekoliko različitih ploča:
- Arduino Ethernet - Ova ploča je opremljena posebnim modulom za izlaz podataka. Za CS izlaz koristi se pin 4. Za ispravan rad mora se koristiti naredba SD.begin(4).
- Adafruit Micro-SD je razvojna ploča koja se koristi pri radu s Micro-SD karticama.
- Sparkfun SD - montiran na vrh Arduina, CS koristi pin 8 za izlaz. Nova verzija ploče ima priključak od 3,3 V i ugrađen šest-bitni inverter.
Spajanje SD i microSD na Arduino
Postoje dvije vrste kartica - microSD i SD. Identični su po vezi, strukturi i programu, ali se razlikuju samo po veličini. Prije uporabe savjetuje se formatiranje SD kartice. Obično su nove kartice već formatirane i spremne za upotrebu, ali ako koristite staru karticu, bolje ju je formatirati u Arduino datotečnom sustavu. Da biste izvršili postupak, SD knjižnica mora biti instalirana na računalu, po mogućnosti FAT16. Za formatiranje u sustavu Windows potrebno je kliknuti na ikonu kartice i kliknuti na “Format”.
Za povezivanje kartice koristi se 6 kontakata, interakcija se vrši preko SPI sučelja. Izgleda kao šesteropinski konektor na ploči. Za spajanje kartice potreban vam je sam kontroler, modul kartice i 6 žica. Osim SPI postoji i SDIO mod, ali je teško implementiran i slabo kompatibilan s Arduinom. SPI se lako konfigurira za rad sa svim mikrokontrolerima, pa ga je preporučljivo koristiti.
Digitalni pinovi su povezani na sljedeći način: za Arduino Nano ili Uno ploču, MOSI pin je spojen na D11, MISO na D12, SCK na D13, CS na 4, VCC na +5 V, .GND na GND. Ploča ima konektore za spajanje na 3,3 i 5 volti. Napajanje same kartice je 3,3 volta pa je lakše koristiti mikrokontroler s istim napajanjem, inače su vam potrebni pretvarači naponske razine. Na najčešćim Arduino pločama postoji takav izlaz.
Prilikom spajanja SD kartice morate uzeti u obzir korespondenciju SPI pinova za različite vrste Arduino ploča:
Arduino biblioteka za rad sa SD i microSD
Za praktičnost rada s vanjskim pogonima podataka, gotove biblioteke dostupne su u Arduino IDE. U većini slučajeva nećete morati ništa preuzimati ili instalirati.
Za uključivanje biblioteke u skicu upotrijebite naredbu uključivanja:
#uključi
SPI biblioteka je potrebna za ispravan rad uređaja povezanih preko SPI.
Za čitanje i pisanje podataka na karticu potrebne su funkcije knjižnice. Knjižnica podržava SD i SDHC kartice.
Imena se pišu u formatu 8.3, odnosno 8 znakova za ime, 3 za ekstenziju. Put do datoteke zapisan je pomoću kose crte "/".
Primjeri ugrađene SD knjižnice
Arduino IDE ima ugrađene primjere za brzo učenje funkcija biblioteke:
- Card Info je ekstrakcija informacija pohranjenih na SD kartici. Uz njegovu pomoć možete saznati u kojem je datotečnom sustavu kartica formatirana, količinu slobodnog prostora, koji su podaci snimljeni.
- Yun Datalogger - omogućuje snimanje podataka s tri senzora na kartici.
- Datalogger - registrira i sprema podatke primljene od senzora na karticu.
- Dump File - pročitajte podatke s kartice, prenesite ih na serijski port.
- Datoteke - stvara i briše podatke. Postoji funkcija file.write() koja stavlja zapisane podatke u međuspremnik. Premještanje informacija na kartu događa se prilikom poziva funkcija flush() ili close(), stoga je važno zatvoriti ih nakon svakog otvaranja datoteke, inače će se podaci izgubiti.
- Read Write - piše i čita datoteke s kartice.
Funkcije SD knjižnice
Arduino SD biblioteka sadrži razne funkcije koje se mogu koristiti za manipuliranje podacima. Funkcije klase SD:
- begin() - funkcija inicijalizira biblioteku, dodjeljuje kontakt za signal.
- exists() - dizajniran je za provjeru ima li karta potrebne informacije.
- mkdir() - omogućuje stvaranje željene mape na memorijskoj kartici.
- rmdir() - Pomoću ove funkcije možete izbrisati mapu. Važno je da mapa koju želite obrisati bude prazna.
- open() - omogućuje vam otvaranje datoteke koju trebate pisati ili čitati. Ako potrebna datoteka nije na karti, bit će kreirana.
- remove() - uklanja sve datoteke.
Kao odgovor na sve ove funkcije, jedna od vrijednosti mora doći - istinito, u slučaju uspješnog završetka operacije i lažno u slučaju neuspjeha.
Stvaranje, uređivanje i brisanje datoteka.
Za rad s datotekama u arduinu postoji klasa File. Uključuje funkcije koje su dizajnirane za pisanje i čitanje informacija s kartice:
- available() - Provjerava sadrži li datoteka bajtove koji su dostupni za čitanje. Odgovor je količina prostora koji je dostupan za čitanje.
- close() - zatvara datoteku, prije toga provjerava jesu li podaci spremljeni na karticu.
- flush() - funkcija vam omogućuje da provjerite jesu li podaci upisani na karticu.
- name() - vraća pokazivač na ime.
- peek() - čita bajtove podataka, pritom ne pomičući pokazivač na sljedeći znak.
- position() - pronalazi trenutnu poziciju pokazivača u datoteci.
- print() - ispisuje podatke u zasebnu datoteku.
- println() - ispisuje podatke u datoteku do mjesta gdje se pojavi znak za početak i prazan redak.
- seek() - mijenja poziciju trenutne pozicije u datoteci.
- size() - prikazuje informacije o veličini podataka.
- read() - čita informacije.
- write() - piše u datoteku.
- isDirectory() - ovom metodom provjerava je li datoteka direktorij, odnosno mapa ili mapa.
- openNextFile() - prikazuje naziv sljedeće datoteke.
- rewindDirectory() - vraća na prvu datoteku u direktoriju.
Da bi ploča radila ispravno, morate biti sigurni da je SS izlaz konfiguriran.
Skica primjera rada s Arduino SD bibliotekom
Ispod je skica koja prikazuje primjer rada s modulom memorijske kartice.
/* Data logger korištenjem SD kartica Primjer pohranjivanja podataka s analognih priključaka na SD kartici. Podaci će biti spremljeni u datoteci kao skup linija s razdjelnikom polja u obliku simbola "," Dijagram ožičenja: * Analogni senzori povezani su na analogne pinove * Modul SD kartice povezan je na SPI prema standardnoj shemi: ** MOSI - pin 11 ** MISO - pin 12 ** CLK - pin 13 ** CS - pin 4 */ #include
Stvaranje datoteke i odabir naziva za arduino SD karticu
Stvaranje datoteke jedan je od najčešćih zadataka pri radu sa SD karticama u Arduinu. Kao što smo vidjeli u prethodnoj skici, da biste stvorili datoteku, jednostavno je otvorite. Ako želimo provjeriti postoji li takva datoteka, možemo koristiti funkciju exists():
- SD.exists("datalog.csv");
Funkcija vraća TRUE ako datoteka postoji.
Popularna praksa pri stvaranju projekata za snimanje podataka je dijeljenje velikih datoteka u manje koje je prikladnije ažurirati i otvoriti na računalu. Na primjer, umjesto jedne vrlo velike datoteke datalog.csv na SD kartici, možete imati nekoliko malih dodavanjem broja na kraju: datalog01.csv, datalog02.csv itd.
Evo primjera skice koji će vam pomoći da obavite posao:
char naziv datoteke = "datalog00.csv"; // Početno ime za (uint8_t i = 0; i< 100; i++) { filename = i / 10 + "0"; filename = i % 10 + "0"; if (! SD.exists(filename)) { // Проверяем наличие logfile = SD.open(filename, FILE_WRITE); break; // Дальше продолжать смысла нет } }
Zaključak
Kao što smo vidjeli, spajanje SD memorijske kartice na Arduino i njezino korištenje u projektu nije jako teško. Za to postoje gotove biblioteke u Arduino IDE i širok izbor opcija modula. Memorijsku karticu možete kupiti u bilo kojoj trgovini elektronike, jeftine su, a istovremeno mogu značajno proširiti potencijal Arduino ploče. Korištenjem memorijskih kartica mogu se prikupiti i pohraniti velike količine podataka za kasniju analizu. Uz pomoć našeg članka, moći ćemo obdariti naše istraživačke projekte memorijom, stvoriti sustave glasovnih najava za pametnu kuću, stvoriti jednostavan wav player i još mnogo toga.
