Povezujemo sd kartice na abr. Povezujemo SD memorijsku karticu sa STM32 preko SPI

Sliku smo prikazali na displeju sa SD kartice, ali su neke tačke u njoj promašene, prva - povezivanje same kartice, druga - uzet je u obzir samo deo funkcija biblioteke Petit FatFs Pogledajmo bliže ove tačke.

Komunikacija sa karticom je moguća preko jednog od dva interfejsa, SPI ili SD.

Moram reći da SD sučelje može raditi u jednobitnom i četverobitnom načinu rada.

Šema za povezivanje kartice preko SPI je standardna i izgleda ovako, neiskorišteni pinovi kartice moraju biti povezani na napajanje pomoću 10K otpornika.

Ali u amaterskim dizajnima, pull-up otpornici se često zanemaruju, što pojednostavljuje dijagram povezivanja.

Treba napomenuti da je pri povezivanju preko SPI-a kartica veoma zahtjevna za napon napajanja i mali pad napona dovodi do neispravnosti kartice, to je testirano na lično iskustvo, Nemam šta reći o SD interfejsu, nisam ga još isprobao. Sve ovo je napisano za napajanje potrebno je ugraditi kondenzatore. Što se tiče induktora, on mora biti naznačen za struju do 100mA, ali ga nije potrebno instalirati.

Gore prikazani dijagrami pokazuju da je kartici potrebno 3,3 volta za rad, odnosno u vodovima za prijenos podataka, napon ne bi trebao prelaziti raspon od 0 - 3,3 volta, i tu se postavlja pitanje šta ako se MC napaja od 5 volti?
Odgovor je jednostavan, potrebno je uskladiti linije podataka, a to se može učiniti pomoću konvencionalnog otpornog razdjelnika.

Dijagram pokazuje da MISO linija ne mora biti uparena jer se podaci prenose preko ove linije sa kartice na MK.
Zapravo, malo ljudi povezuje karticu direktno na MK, mnogo je praktičnije spojiti konektor kartice na MK ili kupiti štit s konektorom i svim potrebnim uprtačem.

Shvatili smo vezu, sada pogledajmo kako koristiti biblioteku Petit FatFs, koji je dizajniran za 8-bitne mikrokontrolere sa malom veličinom memorije.

Biblioteka se sastoji od 5 fajlova:
cijeli broj.h- datoteka zaglavlja koja opisuje glavne tipove podataka.

diskio.h- datoteka zaglavlja koja deklarira prototipove funkcija niske razine za rad s diskom i statusne kodove koje vraćaju.

diskio.c- funkcije niskog nivoa treba implementirati u ovaj fajl, u početku postoje "stubovi".

pffconf.h- konfiguracijski fajl.

pff.h- datoteka zaglavlja u kojoj su deklarisani prototipovi funkcija za interakciju sa datotečnim sistemom diska.

pff.c- datoteka sadrži implementacije funkcija za interakciju sa sistemom datoteka diska.

Vidi se da je za rad biblioteke potrebno implementirati funkcije niskog nivoa. Ali ako govorimo o AVR-u ili PIC-u, za njih na stranici možete preuzeti primjer rada s bibliotekom, koji sadrži datoteku mmc, funkcije niskog nivoa su već implementirane u njemu. Također je potrebno podesiti konfiguraciju biblioteke u pff.h datoteci i napisati funkcije potrebne da bi SPI radio.

Funkcije Petit FatF-a.

FRESULT pf_mount (FATFS*)- funkcija montira/demontira disk. Ova funkcija se mora pozvati prije početka rada s diskom, ako pozovete funkciju sa null pokazivačem, disk se demontira. Funkcija se može pozvati u bilo kojem trenutku.

Opcije
FATFS* fs- pokazivač na objekat tipa FATFS, opis ove strukture se može naći u pff.h datoteci. Samo trebamo deklarirati varijablu ovog tipa.

Povratne vrijednosti:
FR_OK (0)
FR_NOT_READY- uređaj nije mogao biti inicijaliziran
FR_DISK_ERR- došlo je do greške prilikom čitanja sa diska
FR_NO_FILESYSTEM- disk nema važeću FAT particiju

FATFS fs;//Deklarirajte objekat tipa FATFS //Montirajte disk if (pf_mount(&fs) == FR_OK) ( //Disk je montiran, radi se s njim //Demontirajte disk pf_mount(NULL); ) else ( //Neuspješno montiranje diska )

FRESULT pf_open (konstantni znak* put)- funkcija otvara postojeću datoteku. Nakon što se datoteka otvori, možete raditi s njom, odnosno čitati iz nje i pisati u nju. Možete raditi s otvorenom datotekom dok se ne otvori druga datoteka. Funkcija se može pozvati u bilo kojem trenutku.

Opcije
const char*path- pokazivač na niz koji označava putanju do datoteke. Putanja mora biti specificirana u potpunosti 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_ENABLED- disk nije montiran

FATFS fs;//deklariranje objekta tipa FATFS //montiranje diska if (pf_mount(&fs) == FR_OK) ( //otvaranje datoteke koja se nalazi u korijenskom direktoriju if(pf_open("hello.txt") == FR_OK ) ( //nešto radim ) //otvorimo datoteku koja se nalazi u folderu new if(pf_open("new/hello.txt") == FR_OK) ( //uradi nešto ) //demontiraj disk pf_mount(NULL); ) else ( // nije uspio montirati disk)

FRESULT pf_read(void* buff, WORD btr, WORD* br)- funkcija čita određeni broj bajtova iz datoteke i sprema ih u bafer. Ako je broj pročitanih bajtova manji od navedenog, tada je dostignut kraj datoteke.
#define _USE_READ 1

Opcije:
void*buff- pokazivač na bafer u kojem se pohranjuju pročitani podaci
WORD btr- broj bajtova za čitanje
WORD*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- fajl nije otvoren
FR_NOT_ENABLED- disk nije montiran

FATFS fs;//deklarisanje objekta tipa FATFS BYTE buff;//bafer za čitanje datoteke WORD br; // brojač pročitanih bajtova // montiraj disk if (pf_mount(&fs) == FR_OK) ( // otvorimo datoteku koja se nalazi u korijenskom direktoriju if(pf_open("hello.txt") == FR_OK) ( // pročitaj 10 bajtova od toga pf_read(buff, 10, &br); if(br != 10) ( //ako br nije jednako 10 //to znači da smo stigli do kraja datoteke ) ))

FRESULT pf_write(const void* buff, WORD btw, WORD* bw)- funkcija vam omogućava da upišete podatke u otvorenu datoteku. Da bi funkcija radila u datoteci pffconf.h, potrebno je da pišete
#define _USE_WRITE 1

Opcije:
void*buff- pokazivač na bafer koji želimo da upišemo, nulta vrednost završava pisanje
WORD btw- broj bajtova koji želimo da upišemo
WORD*bw- pokazivač na promjenljivu koja pohranjuje broj bajtova koji se mogu napisati. Analizom ove varijable možete saznati da li je dostignut 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- fajl nije otvoren
FR_NOT_ENABLED- 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 kreirati nove datoteke, a možete pisati samo u postojeće
• veličina datoteke se ne može povećati
• ne može ažurirati vremensku oznaku
• operacija pisanja može biti pokrenuta/zaustavljena samo na granici sektora
• atribut datoteke samo za čitanje ne može spriječiti pisanje

Da biste razumjeli pretposljednju tač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 da upišemo 1000 bajtova, tada će prvi sektor biti upisan u potpunosti, a samo 488 bajtova će biti upisano u drugi, a preostala 24 bajta će biti popunjena nulama.

Da pišete u otvorenu datoteku, uradite 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 null 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 otvori datoteku. Možete postaviti pokazivač s apsolutnim ili relativnim pomakom; za apsolutni pomak, morate prenijeti broj funkciji
pf_lseek(5000);
za relativno, proslijedite vrijednost pokazivača na trenutnu poziciju fs.fptr i količinu pomaka
pf_lseek(fs.fptr + 3000);
Da bi funkcija radila u datoteci pffconf.h, potrebno je da pišete
#define _USE_LSEEK 1

Opcije:
DWORD ofset je broj bajtova na koji se pomjera 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- fajl nije otvoren

Možete upisati podatke u datoteku na sljedeći način.
FATFS fs;//deklarisanje objekta tipa FATFS BYTE buff;//bafer za čitanje datoteke WORD br; // brojač pročitanih bajtova // montiraj disk if (pf_mount(&fs) == FR_OK) ( // otvori datoteku koja se nalazi u korijenskom direktoriju if(pf_open("hello.txt") == FR_OK) ( // postavi pokazivač na prvi sektor pf_lseek(0); //write pf_write(buff, 10, &br); //finalizirajte pisanje pf_write(0, 0, &br); ) )

Ovdje također ostavljam dio stvarno funkcionalnog koda koji koristi sve gore opisane funkcije.
#define F_CPU 8000000UL #define buff_size 10 #include #include #include "diskio.h" #include "pff.h" #include "spi.h" FATFS fs;//deklarisanje objekta tipa FATFS BYTE read_buff;//bafer za čitanje datoteke BYTE write_buff = "zdravo riječ"; /// /bafer za upis u datoteku UINT br; // brojač bajtova učitanih int main(void) ( // montiraj disk if (pf_mount(&fs) == FR_OK) ( // otvori datoteku u folderu new if(pf_open("new/hello.txt") = = FR_OK) ( //postaviti pokazivač pisanja pf_lseek(0); //write pf_write(write_buff, buff_size, &br); //finalizirati pisanje pf_write(0, 0, &br); //postaviti pokazivač čitanja pf_lseek(0); / /pročitaj da smo napisali pf_read(read_buff, buff_size, &br); if(br != buff_size) ( //ako br nije jednako buff_size //to znači da smo stigli do kraja datoteke ) ) //mount the file disk pf_mount(NULL); ) while(1) ( ) )

FRESULT pf_opendir(DIR* dp, const char * put)- funkcija otvara postojeći direktorij i kreira pokazivač na objekt tipa DIR, koji će se koristiti za dobivanje liste datoteka u otvorenom direktoriju.
Da bi funkcija radila u datoteci pffconf.h, potrebno je da pišete
#define _USE_DIR 1

Opcije:
DIR *dp- pokazivač na varijablu tipa DIR.

const char *putanja- pokazivač na niz koji sadrži putanju do direktorija, direktoriji su odvojeni kosom crtom

Povratne vrijednosti:
FR_OK (0)- vraća se u slučaju uspješnog izvršenja funkcije
FR_NO_PATH- nisam mogao pronaći put
FR_NOT_READY- Inicijalizacija diska nije uspjela
FR_DISK_ERR- greška na disku
FR_NOT_ENABLED- disk nije montiran

//deklarisanje varijabli FATFS fs; DIR dir; // montiranje diska pf_mount(&fs); //otvori direktorij pf_opendir(&dir, "MY_FOLDER");

FRESULT pf_readdir(DIR* dp, FILINFO* fno)- funkcija omogućava čitanje sadržaja direktorija. Da biste to učinili, otvorite direktorij s funkcijom pf_opendir() i pozovite pf_readdir(). Svaki put kada se funkcija pozove, ona će vratiti ime objekta (fascikla/fajl) koji se nalazi u navedenom direktoriju. Kada prođe kroz sve objekte, vratit će null string u elementu niza fno.fname.
Da bi funkcija radila u datoteci pffconf.h, potrebno je da pišete
#define _USE_DIR 1

Opcije:
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šan završetak funkcije
FR_DISK_ERR- greška na disku
FR_NOT_OTVOREN- imenik nije otvoren

FATFS fs; FRESULT res; FILINFO fno; DIR dir; // montiranje diska pf_mount(&fs); //otvori direktorij res = pf_opendir(&dir, MY_FOLDER); //pročitaj sadržaj direktorija for(;;)( res = pf_readdir(&dir, &fno); //provjeri da li je bilo grešaka pri čitanju // i ima li još datoteka u navedenom direktoriju if ((res ! = FR_OK) || ( fno.fname == 0))( break; ) //prikaži na zgodan način fno.fname usart_sendStr(fno.name); usart_sendStr(/r); )

I na kraju, radni projekat ostavljam ovdje

Lekcija 33

Dio 1

SPI. Sd kartica. DEBEO

Danas ćemo nastaviti našu omiljenu temu o SPI interfejsu. Završili smo sa ovom sabirnicom jedni drugima kontroleri Atmega8a i ATTtiny2313. A danas ćemo pokušati da povežemo memorijsku karticu sa mikrokontrolerom preko ove magistrale koristeći ovaj interfejs SD (Secure Digital).

Ova kartica se može povezati i preko SDIO sučelja, ali pošto takav interfejs nije podržan od strane hardvera našeg kontrolera, nećemo ga dirati u ovoj lekciji. Zanima nas vrsta autobuske veze SPI, pošto već imamo dobro akumulirano znanje o ovoj temi, kao i hardversku podršku u kontroleru koji programiramo.

Ipak, vidjet ćemo pinout nogu kartice za oba tipa.

Pa, pošto nas zanima druga vrsta, bavićemo se njome.

I tu zaista nema šta da se razume. Sve ove skraćenice su nam poznate. Ovdje su sve standardne noge SPI interfejsa i tu nema ništa suvišno.

Sada o mapi općenito. Ova kartica nam omogućava pohranjivanje podataka, njen tip memorije je FLASH, koja je u poređenju sa memorijom tipa EEPROM također nepostojana, odnosno kada se napajanje isključi podaci ne nestaju nigdje, već ostaju pohranjeni. Takođe, ova memorija ima razlike, sa njima ćemo se upoznati u procesu programiranja. Jedna od glavnih razlika je u tome što ne možemo upisati jedan bajt u ovu memoriju, kao u EEPROM memoriji. Teoretski, naravno da možemo, ali tamo će biti zapisane samo jedinice iz našeg bajta ili samo nule, u zavisnosti od tipa FLASH-a - NOR ili NAND. Odnosno, prije nego što napišete bajt, morate ga obrisati, a zbog organizacije ove memorije možemo brisati samo u blokovima, a samim tim i pisati samo u blokovima. Ali postoji najveća razlika u odnosu na EEPROM - ovo je cijena. To je višestruko jeftinije, čak ponekad i po redovima veličine za jednu pohranjenu jedinicu informacije (po megabajtu, po gigabajtu). Stoga FLASH memorija obično ima mnogo veću količinu informacija.

Postoje 4 vrste SD-a, ali ćemo to proučiti nešto kasnije.

Povežimo ovu karticu dok smo u Proteusu

Ovdje je sve jednostavno. Zapravo ne baš tako. Treba još otpornika

Ovi otpornici su potrebni da bi se obezbedili odgovarajući nivoi, pošto se kartica napaja sa 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 u stvari ćemo našu karticu napajati iz zasebnog napajanja ugradnjom mikrokola 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đe imamo povezan ekran, kao u proširenju funkcionalnosti biblioteke ekrana.

Ovako to izgleda u praksi

Ovako izgleda modul sa držačem

Takav modul možete pronaći svuda, košta peni. Modul koji se povezuje preko SDIO košta više. Također vidimo da je na modulu već ugrađeno mikrokolo za snižavanje napona na 3,3 volta. I spajamo napajanje samo na kontakt od 5 volti, a ne spajamo ništa na 3.3

Također, svi razdjelnici nivoa su instalirani na modulu, odnosno ovaj modul je dizajniran posebno za povezivanje sa 5-voltnim uređajima.

I iskopao sam fleš karticu za testove za 32 megabajta, tačno megabajt a ne gigabajt

Ova fleš kartica je donirana uz nekakvu kameru i ona će nam najbolje odgovarati za naše testove, barem nećemo pomisliti da imamo ovaj ili onaj kvar zbog previše memorije na kartici.

Kod je također preuzet iz posljednje lekcije zajedno sa bibliotekom prikaza, jer ćemo funkciju koju smo kreirali u prošloj lekciji koristiti vrlo aktivno, samo je naravno kreiran novi projekt i imenovan u skladu s tim MYSD_SPI.

Izbrišite nepotrebne linije, u main() ćemo imati samo ovo

intmain( void)

nepotpisaninti;

Port_ini();

LCD_ini(); //inicijaliziranje prikaza

clearlcd(); //brisanje ekrana

setpos(0,0);

str_lcd( "String 1");

setpos(2,1);

str_lcd( "string2");

setpos(4,2);

str_lcd( "string 3");

setpos(6,3);

str_lcd( "string 4");

Delay_ms(2000);

// za (i=0;i<=22;i++) {str80_lcd(buffer2+i*20);_delay_ms(1000);}

Dok(1)

Pošto tekst nećemo prikazivati ​​znak po znak, biće moguće proći sa tipom char u varijabli

nepotpisanchar i;

Sada još jedna nijansa.

Da bismo mogli da radimo sa SD karticom u Proteusu, nije nam dovoljno da dodamo držač sa samom karticom, potrebno je i da priložimo datoteku slike fleš kartice u njena svojstva.

Nije ga teško stvoriti. Jedan od načina je kreiranje pomoću programa WinImage.

Standardno kreiramo novu datoteku u njoj koristeći stavku menija Datoteka -\u003e Novo. Odaberite posljednju stavku u dijalogu i kliknite na "OK"

Za test u Proteusu nam je sasvim dovoljna veličina od 4 megabajta, pa ćemo u sljedećem dijalogu promijeniti polje sa brojem sektora, a također odabrati format FAT12/16, jer sa 32-bitnim fajlom sistem malo drugačije specifičnosti rada, a također kliknite "OK"

Generalno, naravno, možemo ostaviti i FAT32, pošto još ne radimo sa fajl sistemom, ali u narednim delovima lekcije ćemo raditi sa fajl sistemom i radićemo sa 12/16.

Zatim spremamo kreiranu datoteku koristeći stavku menija File -> Save As. I mi ga spremamo u fasciklu u kojoj imamo sačuvani proteus projekat. Imenujte datoteku i kliknite na "Sačuvaj"

Takođe, tada ćete morati da se uverite da nismo dobili ovaj fajl sa atributom "samo za čitanje", a nakon toga ga već možemo povezati u proteusu. Bit će potrebno ručno unijeti naziv datoteke, jer proteus zahtijeva neku vrstu vlastitog formata i naš fajl jednostavno neće biti vidljiv

Ne treba nam nikakva putanja, pošto imamo datoteku u fascikli projekta. Pritisnemo "OK".

Ne trebamo inicijalizirati sabirnicu, pošto ćemo imati softverski SPI, ne rade sve fleš kartice ispravno sa hardverskim flash karticama, tada nećemo morati koristiti nikakve registre. Naravno, hardverski je bolji, ali da biste temeljno razumjeli rad protokola, potrebno je raditi i sa softverom, odnosno trzati nogama portova. Općenito, gledajući dijagram, može se činiti da imamo sve u hardveru, pošto sam odabrao upravo takve noge, to je zato što sam ih samo izabrao da kasnije, jednog dana, možda neko ipak pokuša raditi s gumama za implementaciju hardvera .

Dodajte makro zamjene za pinove portova

#include"glavni.h"

#defineMOSI3

#defineMISO4

#defineSCK5

#defineSS2

Dodajmo kod za inicijalizaciju nogu funkciji inicijalizacije porta

voidport_ini( void)

PORTD=0x00;

DDRD=0xFF;

PORTB|=(1<< SS)|(1<< MISO)|(1<< MOSI);

DDRB|=(1<< SS)|(1<< MOSI)|(1<< SCK);

Ostavljamo MISO nogu na ulazu, pošto su po defaultu svi bitovi u registru nula, i jednostavno ga ne dodirujemo. Također odmah uključujemo visoki nivo u MOSI i SS, i povlačimo otpornik na MISO.

Napišimo funkciju za prijenos bajta preko SPI magistrale

voidSPI_SendByte( nepotpisancharbajt)

{

}

Dodajte varijablu za petlju i samu petlju

voidSPI_SendByte( nepotpisancharbajt)

nepotpisanchari;

za( i=0; i<8; i++) // pomicanje za bitove bajta

{

}

Mislim da je razumljivo zašto brojimo do 8, pošto prenosimo tačno 8 bita.

Pa, hajde da ih potajno prebacujemo.

Hajde da prvo provjerimo krajnji lijevi bit, birajući ga iz cijelog bajta maskiranjem, i ako ga imamo jednak 1, onda ga postavimo na 1 na MOSI sabirnici, a ako je 0, onda ne diramo sabirnicu

za( i=0; i<8; i++) // pomicanje za bitove bajta

Dobar dan svima! Danas ćemo pričati o povezivanje SD memorijske kartice na STM32 mikrokontroler.

Čini se da kontroleri STM32F10x imaju puno memorije, zašto postoji dodatna, ali ovaj utisak je varljiv) Na primjer, na displeju trebamo prikazati nekoliko različitih slika - format 320 * 240 - tj. 76800 piksela, od kojih svaki odgovara čak 2 bajta. Tako dobijamo oko 150 kB po slici. A to je mnogo po standardima mikrokontrolera i nije činjenica da se u njegovu Flash memoriju mogu ugurati dvije različite slike. Ili moramo pohraniti velike količine informacija, podataka s nekog senzora, na primjer. Štaviše, tako da su ovi podaci dostupni čak i nakon što je napajanje isključeno. Ovdje eksterna memorija dolazi u obzir. I odlično rješenje SD memorijska kartica ili MMC. Usput, u ovom članku ćemo provesti eksperimente na micro SD kartica.

Prvo, nekoliko riječi o samoj memorijskoj kartici, odnosno o njenom pinoutu. Cela stvar izgleda ovako:

Pa šta mi imamo ovde? Pa odmah se vidi da ima čak osam zaključaka. Dodjela pinova je kako slijedi (s lijeva na desno):

Stupac SPI Mode nam nagovještava da je u interakciji sa mikrokontrolerom koristeći SPI interfejs. ALI! Ići ćemo drugim putem 😉 Stvar je u tome što STM32 u sebi ima gotov periferni modul za rad sa memorijskim karticama, a zove se SDIO.

Općenito, interakcija s memorijskim karticama se sastoji u prenošenju određenih komandi na njih. Neke naredbe zahtijevaju argument, neke ne. Komande se mogu naći u službenoj dokumentaciji za određenu karticu. Dakle, ugrađeni SDIO modul omogućava umnogome pojednostaviti proces prenošenja komandi, a zapravo i proces rada sa eksternim memorijskim karticama. Na primjer, ovdje je registar SDIO_CMD- tamo jednostavno zapišemo kod naredbe koju želimo prenijeti na karticu. Ili ovdje je registar statusa SDIO_STA- postoje čak 24 zastavice za svako kihanje, odnosno za veliki broj događaja.

Inače, STM raduje i dobru dokumentaciju za cijelu stvar. Evo, na primjer, detaljnog opisa inicijalizacije za SD memorijsku karticu (sve je opisano slično za druge vrste kartica):

Pa, zapravo, vrijeme je da pređemo na praktičan primjer. Zaronimo po Standardnoj perifernoj biblioteci.

U fajlu stm32f10x_sdio.h tradicionalno, pronalazimo strukture za sve vrste podešavanja - to jest, za odabir izvora signala takta, frekvenciju SDIO kontrolera i podešavanje broja bajtova koji se prenose. Tamo je sve tako velikodušno komentarisano da ne želim ni da ponavljam posebno)) Samo pogledajte:

typedef struct ( uint32_t SDIO_ClockEdge; /* Određuje tranziciju sata na kojoj se vrši hvatanje bita. Ovaj parametar može biti vrijednost @ref SDIO_Clock_Edge */ uint32_tSDIO_ClockBypass; /* Određuje da li je zaobilaženje razdjelnika SDIO sata omogućena ili onemogućena. Ovaj parametar može biti vrijednost @ref SDIO_Clock_Bypass */ uint32_tSDIO_ClockPowerSave; /* Određuje da li je izlaz SDIO sata omogućen ili onemogućen kada je magistrala neaktivna. Ovaj parametar može biti vrijednost @ref SDIO_Clock_Power_Save */ uint32_tSDIO_BusWide; /* Određuje širinu SDIO magistrale. Ovaj parametar može biti vrijednost @ref SDIO_Bus_Wide */ uint32_t SDIO_HardwareFlowControl; /* Određuje da li je 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 komande koji se šalje na karticu kao dio komandne poruke. Ako naredba sadrži argument, mora se učitati u ovaj registar prije pisanja naredbe u registar komandi */ uint32_t SDIO_CmdIndex; /* Određuje indeks SDIO komande. Mora biti manji od 0x40. */ uint32_t SDIO_Response; /* Određuje tip SDIO odgovora. Ovaj parametar može biti vrijednost @ref SDIO_Response_Type */ uint32_tSDIO_Wait; /* Određuje da li je SDIO zahtjev čekanja na prekid omogućen ili onemogućen. Ovaj parametar može biti vrijednost @ref SDIO_Wait_Interrupt_State */ uint32_t SDIO_CPSM; /* Određuje da li je mašina stanja staze SDIO komande (CPSM) omogućena ili onemogućena. Ovaj parametar može biti vrijednost @ref SDIO_CPSM_State */) SDIO_CmdInitTypeDef; typedef struct ( uint32_t SDIO_DataTimeOut; /* Određuje period vremena čekanja podataka u časovima sabirnice kartice. */ uint32_tSDIO_DataLength; /* Određuje broj bajtova podataka koji će se prenijeti. */ 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 da li je prijenos podataka u stream ili blok modu. Ovaj parametar može biti vrijednost @ref SDIO_Transfer_Type */ uint32_t SDIO_DPSM; /* Određuje da li je 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 komandi na memorijsku karticu. Za ove namjene je izdvojena posebna struktura. SDIO_CmdInitTypeDef. U polju SDIO_CmdIndex unesite komandni kod u polje SDIO_Argument- argument naredbe, također popunite preostala polja. Ostaje nekako gurnuti ove podatke u mikro SD karticu 😉 A za to smo pripremili funkciju:

SDIO_SendCommand (SDIO_CmdInitTypeDef *SDIO_CmdInitStruct)

Kao argument, prenosimo mu istu strukturu koju smo kreirali. Postoji funkcija za pisanje podataka - SDIO_WriteData(uint32_t Data). Nakon pozivanja ove funkcije, podaci će biti u posebno dizajniranom registru - SDIO_FIFO.

Ovako se izvodi rad sa SDIO modulom u STM32F10x)

A sada konačno pređimo na praksu. Opet ću raditi sa Mini STM32 pločom, jer su dobri Kinezi bili zbunjeni instaliranjem utora za micro SD memorijsku karticu na nju. Evo dijagrama povezivanja konektora kartice na mikrokontroler:

Za pisanje programa koristit ćemo gotov primjer za Keil - odatle ćemo ukrasti dvije datoteke u kojima je implementirano nešto poput drajvera za rad s karticama - to su datoteke sdcard.c I sdcard.h Kreiramo novi projekat, povezujemo te fajlove tamo, a pored toga, naravno, CMSIS i SPL fajlove. Evo gotovog projekta, u koji je sve već dodano - ostaje samo napisati kod za glavnu () funkciju)

Datoteka sdcard.c implementira sve vrste funkcija za rad sa memorijskom karticom, sada ih samo moramo koristiti 😉 Hajde da napišemo kod! Na primjer, zapišimo 512 bajtova testnih podataka na mikro SD, a zatim ih pokušajmo pročitati:

// Povezivanje potrebnih fajlova#include "stm32f10x.h" #include "sdcard.h" /*******************************************************************/ // Nizovi ulaznih i izlaznih podataka i varijabla za pohranjivanje podataka// o našoj mapi uint8_t writeBuffer[ 512 ] ; uint8_t readBuffer[ 512 ] ; SD_CardInfo SDCardInfo; /*******************************************************************/ int main() ( // Testirajte podatke za pisanje za (uint16_t i = 0; i< 512 ; i++ ) { writeBuffer[ i] = i % 256 ; readBuffer[ i] = 0 ; } // Inicijalizacija mape SD_Init() ; // Dobiti informacije o karti SD_GetCardInfo(& SDCardInfo) ; // Odabir karte i podešavanje 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 debagerom, vidjet ćemo da pročitani podaci odgovaraju upisanim podacima =) Tako da se eksperiment može smatrati uspješnim. Ovim je završeno za danas, vidimo se uskoro!

Mikhail Russkikh

Date su kratke informacije o SD karticama, date su osnove rada SD magistrale, objašnjena je procedura korištenja drajvera stm324xg_eval_sdio_sd, dizajniranog da pojednostavi komunikaciju mikrokontrolera porodice STM32 sa SD karticama.

Neki ugrađeni sistemi moraju biti u stanju pohraniti velike količine informacija. Na primjer, snimači različitih fizičkih veličina i parametara (struja, napon, temperatura, geografske koordinate) moraju pohraniti očitanja primljena od senzora na određeni medij, koji bi kasnije mogli biti uklonjeni iz uređaja i povezani s računarom kako bi pregledali podatke. u obliku prilagođenom korisniku. Da bi se riješio ovaj problem, čini se da je najočiglednija upotreba USB fleš diskova. Oni su široko rasprostranjeni na tržištu i omogućavaju vam da pohranite velike količine informacija. Ali za neke male ugrađene sisteme, kompaktnost je najvažnija, a ovi diskovi mogu biti preveliki. Osim toga, nisu svi mikrokontroleri opremljeni USB modulom, a dizajner sistema može provesti dosta vremena baveći se USB stekom, što može povećati vrijeme projekta. U tom smislu, dobra alternativa USB-u je korištenje SD kartica, koje su vrlo kompaktne i omogućavaju razmjenu podataka korištenjem zajedničkog SPI sučelja ili namjenskog interfejsa za SD kartice.

SD (Secure Digital) memorijske kartice su prvenstveno dizajnirane za upotrebu u prijenosnim uređajima. Danas postoji veliki broj modela na tržištu, koje nude kompanije 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, pored uobičajenog prostora za pohranu podataka, imaju posebno zaštićeno područje koje nije dostupno prosječnom korisniku. Da bi uređaj mogao čitati informacije snimljene na SD kartici u obliku datoteka, ova kartica mora imati određeni sistem datoteka. Najpoželjniji sistem u ovom slučaju je FAT sistem, pošto je broj ciklusa pisanja/čitanja za SD kartice ograničen, a sistemi poput NTFS i ext se vode u dnevnik, odnosno uključuju često prozivanje.

Prijenos i prijem podataka vrši se preko SPI interfejsa ili preko SD magistrale. Slika 1 prikazuje dodjelu pinova za različite tipove SD kartica, a tabela 1 prikazuje funkcionalnost ovih pinova.

Tabela 1.	Funkcionalna namjena pinova SD kartice
SPI interfejs SD interfejs SDC kartice miniSD kartice microSD kartice

Iako glavni kontroler može komunicirati s karticom koristeći SPI, SD magistrala i dalje pruža više opcija i omogućava 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 preko SD magistrale

Komunikacija sa SD karticom se odvija preko 6 informacionih linija: 4 linije podataka (DAT0, DAT1, DAT2, DAT3), linije za sinhronizaciju (CLK), linije za prenos komandi (CMD). Kada su povezani na kontroler, linija podataka i komandna linija moraju biti uključeni u napajanje, kao što je prikazano na slici 2.

Upisivanje i čitanje podataka vrši se blok po blok. Tipično, blok se sastoji od 512 bajtova. Prijenos podataka i servisnih informacija zasniva se na modelu interakcije "komanda-odgovor". Prije slanja ili primanja podataka, host 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 tražena radnja. SD standard podržava prisustvo više slave-ova na magistrali, u kom slučaju glavni kontroler može slati komande putem emitiranja. Komanda ima jasnu strukturu koja se sastoji od 48 bita: 1 početni bit, 1 bit prenosa (postavljen na 1), 6 bita za indeks komande, 32 bita za argument, 7 bita za kontrolni zbir i 1 stop bit. Odgovor može imati istu 48-bitnu strukturu (u tom slučaju je bit prijenosa postavljen na 0) ili se sastojati od 136 bita (tzv. format dugog odgovora): 1 početni bit, 1 bit prijenosa (postavljen na 0), 6 rezervisani bitovi, 127 bita CID (Card Identification Register) ili CSD (Card Specific Data Register) sadržaja i kontrolne sume, 1 stop bit.

Na početku rada sa karticom, host kontroler ponovo učitava karticu koristeći komande GO_IDLE_STATE(CMD0) I IO_RW_DIRECT (CMD52). Kompletna lista komandi sa opisima može se naći u (Dodatak A). Nakon ponovnog pokretanja, kartica će vratiti svoje zadane postavke i njena adresa će biti jednaka RCA = 0x0001. Ako je nekoliko kartica spojeno na host, onda pomoću naredbe SET_RELATIVE_ADDR (CMD3) daje svakoj kartici svoju adresu. Također, na početku rada se provjerava napon koji se primjenjuje na karticu. Napon kartice mora biti u strogo utvrđenom rasponu od 2,7 do 3,6 V. U tom smislu, glavni kontroler pomoću komande SEND_OP_COND (CMD1 ili ACMD41) mora saznati trenutni napon na kartici i prestati raditi s njom ako nije u traženom rasponu. Ovo je opći princip inicijalizacije kartice, za koji se, ovisno o vrsti kartice (MMC, SD, SD I/O), mogu koristiti druge komande i dodatni koraci, tako da prilikom implementacije sučelja niskog nivoa potrebno je pažljivo pročitajte dokumentaciju za karticu i proučite CMD komande.

Tokom pisanja, host šalje jedan ili više blokova na karticu koristeći naredbu WRITE_BLOCK (CMD24) ili WRITE_MULTIPLE_BLOCK (CMD25), odnosno, dok na kraju svakog bloka host upisuje kontrolni zbroj. Kartica kojoj je omogućeno upisivanje uvijek će moći primiti blok(ove), ali ako se kontrolni zbroj ne podudara, kartica će prijaviti grešku i neće upisati 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 grupa od nekoliko blokova koristeći naredbu READ_MULTIPLE_BLOCK (CMD18). U slučaju burst prijenosa, domaćin može prekinuti čitanje u bilo kojem trenutku slanjem naredbe STOP_TRANSMISSION (CMD12). Ako tokom prijenosa nekoliko blokova interni kontroler kartice popravi grešku, tada će prestati slati podatke glavnom kontroleru, ali će karticu ostaviti u načinu prijenosa podataka. U ovom slučaju, domaćin će morati prisiliti da se čitanje završi naredbom CMD12, dok će kao odgovor na ovu naredbu kartica prijaviti grešku čitanja.

Organizacija ispravnog rada SD magistrale prilično je naporan proces, jer je pored gore opisanih općih situacija potrebno predvidjeti različite nijanse u ponašanju kartice i implementirati dodatne rukovaoce greškama. Stoga bi najracionalnije rješenje bilo korištenje posebnih biblioteka koje omogućavaju programeru da ne ulazi u detalje prijenosa podataka na hardverskom nivou i značajno skraćuje vrijeme razvoja. Jedna od ovih biblioteka, o kojoj će biti reči u nastavku, je biblioteka drajvera. stm324xg_eval_sdio_sd za popularne mikrokontrolere, što vam omogućava da značajno pojednostavite rad sa SDIO modulom, dizajniranim za interakciju sa SD karticama.

stm324xg_eval_sdio_sd drajver

Ovaj drajver je biblioteka funkcija sa kojima možete implementirati interfejs visokog nivoa za komunikaciju sa SD karticom. Upravljački program se isporučuje za rad sa STM324VG pločom za otklanjanje grešaka (UtilitiesSTM32_EVALSTM3240_41_G_EVAL), ali nakon promjene funkcija koje povezuju ovu biblioteku sa SDIO interfejsom niskog nivoa, može funkcionisati sa mnogim mikrokontrolerima porodice STM32, koji uključuju SDIO modul. Iz prethodne rečenice proizilazi da u projekat treba uključiti datoteke iz standardne biblioteke Standardna periferna biblioteka, koji osiguravaju rad SDIO modula na niskom nivou. Na primjer, za mikrokontrolere serije STM32F4xx, to će biti datoteke stm32f4xx_sdio.c I stm32f4xx_sdio.h.

Prije korištenja funkcija drajvera, programer mora povezati ovaj drajver s hardverom, odnosno konfigurirati linije SDIO modula. Da bi to učinio, on treba da kreira funkcije u glavnoj datoteci svog programa main.c SD_LowLevel_Init() (da biste omogućili SDIO modul) i SD_LowLevel_DeInit() (da biste onemogućili SDIO modul) u kojem ove linije treba konfigurirati. Ako programer želi koristiti modul direktnog pristupa memoriji za povećanje brzine rada sa SD karticom, tada će također morati kreirati funkcije SD_LowLevel_DMA_TxConfig() I SD_LowLevel_DMA_RxConfig() odgovoran za prijenos i prijem podataka pomoću PDP modula. Kao primjer inicijalizacije četiri specificirane funkcije možemo uzeti kod dostupan u datoteci stm324xg_eval.c od (UtilitiesSTM32_EVALSTM3240_41_G_EVAL).

Pogledajmo sada glavne funkcije za rad sa SD karticom koju pruža ovaj drajver. Da biste inicijalizirali mapu, trebate pozvati funkciju SD_Init() , koji konfiguriše SDIO modul pozivajući se na SD_LowLevel_Init() , provjerava tip SD kartice, dobija servisne informacije iz CID i CSD registara, postavlja brzinu prijenosa (po defaultu 24 MHz) i postavlja širinu magistrale (4 bita). Možete čitati podatke primljene sa kartice koristeći funkcije SD_ReadBlock() (za čitanje jednog bloka) i SD_ReadMultiBlocks() (za čitanje više blokova). Da biste upisali podatke 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: tampon(bafer varijabla u koju treba staviti podatke za čitanje i pisanje), adresa(adresa memorijske lokacije SD kartice) i block_size(uvijek 512 jer ove funkcije rade samo na blokovima dugim 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 iz koje će brisanje početi, a drugi specificira adresu ćelije u kojoj će se brisanje završiti.

Prijenos podataka između SDIO modula i memorije mikrokontrolera može se vršiti i na uobičajen način preko centralnog procesora i preko jedinice za direktni pristup memoriji. Da biste odabrali željeni način rada, trebate unijeti datoteku stm324xg_eval_sdio_sd.h dekomentiraj ili liniju #define SD_POLLING_MODE(normalan način rada) ili linija #define SD_DMA_MODE(PDP mod). Nakon bilo koje operacije pisanja ili čitanja, morate koristiti funkciju SD_GetStatus() provjerite da li je kartica završila trenutnu operaciju i da li je spremna za primanje ili slanje novih podataka. Ako ova funkcija vrati SD_TRANSFER_OK, prijenos je uspješno završen, SD_TRANSFER_BUSY vraća da je kanal za prijenos zauzet, a SD_TRANSFER_ERROR vraća grešku prijenosa. Sve ove vrijednosti su definirane u strukturi SDTransferState, snimljeno u stm324xg_eval_sdio_sd.h. Ako je prijenos informacija obavljen preko PDP bloka, tada je dodatno potrebno provjeriti da li je PDP kontroler izvršio sve operacije prijenosa podataka. Ovo se radi pomoću funkcije SD_ReadWaitOperation() . Također je vrijedno napomenuti da se prijenos kroz DMA blok završava prekidom, tako da programer mora organizirati poziv funkcije SD_ProcessIRQ() u rukovaocu prekida modula SDIO SDIO_IRQHandler() i poziv funkcije SD_ProcessDMAIRQ() u rukovaocu prekida DMA2 DMA2_Streamx_IRQHandler() .

Za bolje razumijevanje kako drajver radi stm324xg_eval_sdio_sd možete koristiti radni primjer iz foldera SDIOSDIO_uSDCard(ProjectSTM32F4xx_StdPeriph_ExamplesSDIO). Koristeći ovaj testni program, možete obrisati određeno područje memorije kartice, upisati podatke na određenu adresu, pročitati podatke na istu adresu, a zatim uporediti poslane i primljene informacije. Identitet bafera za prijem i bafera za slanje je indikacija da SDIO modul, komunikaciona magistrala i SD kartica normalno funkcionišu.

Dakle, možemo reći da su SD kartice dostojna konkurencija USB fleš diskovima kada je u pitanju projektovanje malih ugrađenih sistema koji zahtevaju velike količine podataka za skladištenje. Možete prenijeti informacije sa i na karticu koristeći SPI sučelje ili preko SD magistrale, koja je dizajnirana za ovu svrhu i pruža visoku brzinu prijenosa. Implementacija komunikacije sa karticom je uveliko pojednostavljena korišćenjem posebnih drajvera koji olakšavaju rad sa hardverom i nude programerima funkcije jednostavne za korišćenje. Ali, nažalost, podaci napisani nasumičnim redoslijedom neće biti prihvaćeni od strane bilo kojeg operativnog sistema, na primjer, Windowsa, pa će u sljedećem dijelu biti riječi o tome kako raditi sa SD karticom sa FAT sistemom datoteka.

Spisak izvora

SD i microSD kartice mogu značajno proširiti mogućnosti Arduino projekata koji rade sa velikim količinama podataka: data logeri, meteorološke stanice, sistemi pametnih kuća. Arduino ploče su opremljene relativno malom internom memorijom, samo do 4 kilobajta, uključujući i flash memoriju i EEPROM. Ova memorija neće biti dovoljna za pisanje velikih količina podataka, posebno ako se ploča stalno isključuje ili isključuje. Povezivanje Arduino SD kartice kao eksternog diska omogućava vam da umnožite prostor za pohranu bilo koje informacije. Izmjenjivi SD diskovi su jeftini, jednostavni za povezivanje i jednostavni za korištenje. O ispravnom povezivanju SD kartice na Arduino bit će riječi u članku.

Rad sa SD memorijom u arduinu nije posebno težak. Najlakši način je da povežete gotov modul i koristite standardnu ​​biblioteku. Počećemo sa ovom opcijom.

Korištenje gotovog modula ima razne prednosti. Ovo je prilično jednostavan i zgodan alat za rad s velikim količinama podataka. Ne zahtijeva posebne vještine u povezivanju, svi konektori su potpisani direktno na ploči. Morate platiti za praktičnost, ali cijena modula je relativno niska, lako se može naći po pristupačnim cijenama u ruskim i stranim internetskim trgovinama.

Univerzalni modul je obična ploča na kojoj su postavljeni utor za karticu, otpornici i regulator napona. Ima sledeće tehničke karakteristike:

• Raspon radnog napona 4,5-5 V;
• Podržava SD karticu do 2GB;
• struja 80 mA;
• FAT 16 sistem datoteka.

Modul SD kartice implementira funkcije kao što su pohranjivanje, čitanje i upisivanje informacija na karticu, što je potrebno za normalan rad uređaja baziranog na mikrokontroleru.

Naravno, jeftini moduli memorijskih kartica imaju i nedostatke. Na primjer, najjeftiniji i najčešći modeli podržavaju samo kartice do 4 GB, a gotovo svi moduli vam omogućavaju pohranjivanje datoteka veličine do dva gigabajta na SD kartici - ovo je ograničenje FAT sistema datoteka koji se koristi u većini modela.

Još jedan nedostatak memorijskih kartica je relativno dugo vrijeme snimanja, ali postoje načini za rad s njom, što vam omogućava da povećate brzinu. Za to se koristi mehanizam za keširanje, kada se podaci prvo akumuliraju u RAM-u, a zatim se odjednom izbacuju 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 se koristi pin 4. Komanda SD.begin(4) se mora koristiti za ispravan rad.
• Adafruit Micro-SD je razvojna ploča koja se koristi za rad sa Micro-SD karticama.
• Sparkfun SD - montiran na Arduino, CS koristi pin 8 za izlaz. Nova verzija ploče ima priključak od 3.3V i ugrađeni šest-bitni inverter.

Povezivanje SD i microSD na Arduino

Postoje dvije vrste kartica - microSD i SD. Identični su po spoju, strukturi i programu, ali se razlikuju samo po veličini. Prije upotrebe savjetuje se formatiranje SD kartice. Obično su nove kartice već formatirane i spremne za rad, ali ako koristite staru karticu, bolje je formatirati je u Arduino sistemu datoteka. Da biste izvršili proceduru, na računaru mora biti instalirana SD biblioteka, po mogućnosti FAT16. Za formatiranje u Windows-u, potrebno je da kliknete na ikonu kartice i kliknete na “Format”.

Za povezivanje kartice koristi se 6 kontakata, interakcija se vrši preko SPI interfejsa. Izgleda kao šestopinski konektor na ploči. Za povezivanje kartice potreban vam je sam kontroler, modul kartice i 6 žica. Pored SPI, postoji i SDIO mod, ali je težak za implementaciju i slabo kompatibilan sa Arduinom. SPI se lako konfiguriše za rad sa svim mikrokontrolerima, pa se preporučuje da ga koristite.

Digitalni pinovi su povezani na sljedeći način: za Arduino Nano ili Uno ploču, MOSI pin je povezan 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, tako da je lakše koristiti mikrokontroler sa istim napajanjem, inače su vam potrebni pretvarači nivoa napona. Na najčešćim Arduino pločama postoji takav izlaz.

Prilikom povezivanja 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 sa eksternim diskovima podataka, gotove biblioteke su dostupne u Arduino IDE. U većini slučajeva nećete morati ništa da preuzimate ili instalirate.

Da biste uključili biblioteku u skicu, koristite naredbu uključivanja:

#include #include

SPI biblioteka je potrebna za ispravan rad uređaja povezanih preko SPI.

Funkcije biblioteke su potrebne za čitanje i pisanje podataka na karticu. Biblioteka može podržavati SD i SDHC kartice.

Imena se pišu u formatu 8.3, odnosno 8 karaktera za ime, 3 za ekstenziju. Putanja do datoteke piše se kosim crtama "/".

Primjeri ugrađene SD biblioteke

Arduino IDE ima ugrađene primjere za brzo učenje funkcija biblioteke:

• Informacije o kartici su ekstrakcija informacija pohranjenih na SD kartici. Uz njegovu pomoć možete saznati u kojem sistemu datoteka je kartica formatirana, količinu slobodnog prostora, koji podaci se snimaju.
• Yun Datalogger - omogućava vam snimanje log podataka sa tri senzora na kartici.
• Datalogger - registruje i pohranjuje podatke primljene od senzora na karticu.
• Dump File - pročitajte podatke sa kartice, prenesite ih na serijski port.
• Datoteke - kreira i briše podatke. Postoji funkcija file.write() koja stavlja napisane podatke u bafer. Premještanje informacija na mapu događa se prilikom pozivanja funkcija flush() ili close(), pa je važno zatvoriti ih nakon svakog otvaranja datoteke, inače će podaci biti izgubljeni.
• Read Write - piše i čita datoteke sa kartice.

Funkcije SD biblioteke

Arduino SD biblioteka sadrži različite funkcije koje se mogu koristiti za manipulaciju podacima. Funkcije SD klase:

• begin() - funkcija inicijalizira biblioteku, dodjeljuje kontakt za signal.
• exists() - dizajniran je da provjeri da li mapa ima potrebne informacije.
• mkdir() - omogućava vam da kreirate željeni folder na memorijskoj kartici.
• rmdir() - Ovom funkcijom možete izbrisati folder. Važno je da folder koji se briše bude prazan.
• open() - omogućava vam da otvorite datoteku koju trebate napisati ili pročitati. Ako traženi fajl nije na mapi, biće kreiran.
• remove() - uklanja bilo koju datoteku.

Kao odgovor na sve ove funkcije, jedna od vrijednosti mora biti istinita, u slučaju uspješnog završetka operacije i lažna u slučaju neuspjeha.

Kreirajte, uređujte i brišite datoteke.

Za rad sa fajlovima u arduinu postoji klasa File. Uključuje funkcije koje su dizajnirane za pisanje i čitanje informacija s kartice:

• available() - Provjerava da li datoteka sadrži bajtove koji su dostupni za čitanje. Odgovor je količina prostora koja je dostupna za čitanje.
• close() - zatvara fajl, pre toga proverava da li su podaci sačuvani na kartici.
• flush() - funkcija vam omogućava da se uvjerite da su podaci upisani na karticu.
• name() - vraća pokazivač na ime.
• peek() - čita bajtove podataka, dok ne pomera pokazivač na sledeći znak.
• position() - pronalazi trenutnu poziciju pokazivača u datoteci.
• print() - ispisuje podatke u zasebnu datoteku.
• println() - ispisuje podatke u datoteku do tačke u kojoj se pojavljuju povratak na nosivu i prazan red.
• seek() - mijenja poziciju trenutne pozicije u datoteci.
• size() - prikazuje informacije o veličini podataka.
• read() - čita informacije.
• write() - upisuje u datoteku.
• isDirectory() - pomoću ove metode provjerava da li je datoteka direktorij, odnosno direktorij ili mapa.
• openNextFile() - prikazuje ime sljedećeg fajla.
• rewindDirectory() - vraća se na prvu datoteku u direktoriju.

Da bi ploča radila ispravno, morate biti sigurni da je SS izlaz konfiguriran.

Skica primjera rada sa Arduino SD bibliotekom

Ispod je skica koja prikazuje primjer rada s modulom memorijske kartice.

/* Data logger koristeći SD kartice Primjer pohranjivanja podataka sa analognih portova na SD karticu. Podaci će biti sačuvani u datoteci kao skup linija sa separatorom polja u obliku simbola "," ** CLK - pin 13 ** CS - pin 4 */ #include #include const int PIN_CHIP_SELECT = 4; void setup() ( Serial.begin(9600); Serial.print("Inicijalizacija SD kartice..."); // Ovaj pin mora biti definiran kao OUTPUT pinMode(10, OUTPUT); // Pokušavam inicijalizirati modul ako ( !SD.begin(PIN_CHIP_SELECT)) ( Serial.println("Kartica nije uspjela ili nije prisutna"); // Ako je nešto pošlo po zlu, izađi: return; ) Serial.println("kartica je inicijalizirana."); ) void petlja () ( // String sa podacima koje ćemo staviti u datoteku: String logStringData = ""; // Čitanje podataka sa portova i upisivanje u niz za (int i = 0; i< 5; i++) { int sensor = analogRead(i); logStringData += String(sensor); if (i < 4) { logStringData += ","; } } // Открываем файл, но помним, что одновременно можно работать только с одним файлом. // Если файла с таким именем не будет, ардуино создаст его. File dataFile = SD.open("datalog.csv", FILE_WRITE); // Если все хорошо, то записываем строку: if (dataFile) { dataFile.println(logStringData); dataFile.close(); // Публикуем в мониторе порта для отладки Serial.println(logStringData); } else { // Сообщаем об ошибке, если все плохо Serial.println("error opening datalog.csv"); } }

Kreiranje datoteke i odabir imena za arduino SD karticu

Kreiranje datoteke jedan je od najčešćih zadataka pri radu sa SD karticama u Arduinu. Kao što smo vidjeli u prethodnoj skici, da biste kreirali 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 prilikom kreiranja projekata data logera je da se velike datoteke podele na manje koje je pogodnije za ažuriranje i otvaranje na računaru. 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 koja će vam pomoći da obavite posao:

char filename = "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, povezivanje SD memorijske kartice na Arduino i korištenje u projektu nije 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 ujedno mogu značajno proširiti potencijal Arduino ploče. Uz korištenje memorijskih kartica, velike količine podataka mogu se prikupiti i pohraniti za kasniju analizu. Uz pomoć našeg članka, moći ćemo da obdarimo naše istraživačke projekte memorijom, kreiramo sisteme glasovnih najava za pametni dom, kreiramo jednostavan wav player i još mnogo toga.