Savienojam sd kartes ar abr. Mēs savienojam SD atmiņas karti ar STM32, izmantojot SPI
Attēlu displejā rādījām no sd kartes, bet daži punkti tajā izpalika, pirmais - pašas kartes pieslēgšana, otrais - tika ņemta vērā tikai daļa no bibliotēkas funkcijām Petit FatFs Apskatīsim šos punktus tuvāk.
Saziņa ar karti ir iespējama, izmantojot vienu no diviem interfeisiem, SPI vai SD.
Man jāsaka, ka SD interfeiss var darboties viena bita un četru bitu režīmos.
Shēma kartes pievienošanai caur SPI ir standarta un izskatās šādi, neizmantotās kartes tapas jāpievieno barošanas avotam, izmantojot 10K rezistoru.
Bet amatieru dizainā pievilkšanas rezistori bieži tiek atstāti novārtā, vienkāršojot savienojuma shēmu.
Jāņem vērā, ka, pieslēdzot caur SPI, karte ir ļoti prasīga pret barošanas spriegumu un neliels barošanas sprieguma kritums noved pie kartes nedarbošanās, tas ir pārbaudīts Personīgā pieredze, Par SD interfeisu nav ko teikt, vēl neesmu izmēģinājis. Tas viss tika uzrakstīts strāvas padevei ir nepieciešams uzstādīt kondensatorus. Kas attiecas uz induktors, tam jābūt nominālam strāvai līdz 100mA, bet tas nav jāuzstāda.
Iepriekš redzamajās diagrammās redzams, ka kartei ir nepieciešami 3,3 volti, lai strādātu, attiecīgi datu pārraides līnijās spriegumam nevajadzētu pārsniegt 0 - 3,3 voltu diapazonu, un te rodas jautājums, kā būtu, ja MC baro 5. volti?
Atbilde ir vienkārša, jums ir jāsaskaņo datu līnijas, un to var izdarīt, izmantojot parasto pretestības dalītāju.
Diagramma parāda, ka MISO līnija nav jāsaskaņo, jo dati tiek pārsūtīti pa šo līniju no kartes uz MK.
Faktiski maz cilvēku pievieno karti tieši MK, daudz ērtāk ir pievienot kartes savienotāju MK vai iegādāties vairogu ar savienotāju un visu nepieciešamo instalāciju.
Mēs izdomājām savienojumu, tagad apskatīsim, kā izmantot bibliotēku Petit FatFs, kas paredzēts 8 bitu mikrokontrolleriem ar nelielu atmiņas apjomu.
Bibliotēka sastāv no 5 failiem:
vesels skaitlis.h- galvenes fails, kas apraksta galvenos datu tipus.
diskio.h- galvenes fails, kas deklarē zema līmeņa funkciju prototipus darbam ar disku un statusa kodus, ko tie atgriež.
diskio.c- šajā failā jārealizē zema līmeņa funkcijas, sākotnēji ir "stubs".
pffconf.h- konfigurācijas fails.
pff.h- galvenes fails, kurā ir deklarēti funkciju prototipi mijiedarbībai ar diska failu sistēmu.
pff.c- fails satur funkciju ieviešanu mijiedarbībai ar diska failu sistēmu.
Redzams, ka, lai bibliotēka strādātu, ir nepieciešams realizēt zema līmeņa funkcijas. Bet, ja mēs runājam par AVR vai PIC, viņiem vietnē varat lejupielādēt piemēru darbam ar bibliotēku, kurā ir fails mmc, tajā jau ir ieviestas zema līmeņa funkcijas. Tāpat ir jāiestata bibliotēkas konfigurācija failā pff.h un jāieraksta SPI darbībai nepieciešamās funkcijas.
Petit FatF funkcijas.
FRESULT pf_mount (FATFS*)- funkcija uzmontē/demontē disku. Šī funkcija ir jāizsauc pirms darba uzsākšanas ar disku, ja izsaucat funkciju ar nulles rādītāju, disks tiek atmontēts. Funkciju var izsaukt jebkurā laikā.
Iespējas
FATFS* fs- rādītājs uz FATFS tipa objektu, šīs struktūras aprakstu var atrast failā pff.h. Mums vienkārši jādeklarē šāda veida mainīgais.
Atgriešanas vērtības:
FR_OK (0)
FR_NOT_READY- ierīci nevarēja inicializēt
FR_DISK_ERR- lasot no diska, radās kļūda
FR_NO_FILESYSTEM- diskam nav derīga FAT nodalījuma
FATFS fs;//Deklarēt FATFS tipa objektu //Pievienot disku if (pf_mount(&fs) == FR_OK) ( //Disks ir pievienots, darbs ar to //Atmontēt disku pf_mount(NULL); ) else ( //Neizdevās uzstādīt disku)
FRESULT pf_open (const char* ceļš)- funkcija atver esošu failu. Pēc faila atvēršanas varat ar to strādāt, tas ir, lasīt no tā un rakstīt tajā. Varat strādāt ar atvērtu failu, līdz tiek atvērts cits fails. Funkciju var izsaukt jebkurā laikā.
Iespējas
const char*path- rādītājs uz virkni, kas norāda ceļu uz failu. Ceļš ir jānorāda pilnībā attiecībā pret saknes direktoriju, atdalot direktorijus ar slīpsvītru.
Atgriešanas vērtības:
FR_OK (0)- atdod sekmīgas funkcijas izpildes gadījumā
FR_NO_FILE- fails nav atrasts
FR_DISK_ERR- diska kļūda
FR_NOT_ENABLED- disks nav uzstādīts
FATFS fs;//FATFS tipa objekta deklarēšana //diska pievienošana if (pf_mount(&fs) == FR_OK) ( //atverot failu, kas atrodas saknes direktorijā if(pf_open("hello.txt") == FR_OK ) ( //daru kaut ko ) //atveriet failu, kas atrodas mapē new if(pf_open("new/hello.txt") == FR_OK) ( //darīt kaut ko ) //atmontēt disku pf_mount(NULL); ) cits ( // neizdevās uzstādīt disku)
FRESULT pf_read(void* buff, WORD btr, WORD* br)- funkcija nolasa norādīto baitu skaitu no faila un saglabā tos buferī. Ja nolasīto baitu skaits ir mazāks par norādīto, tad ir sasniegts faila beigas.
#define _USE_READ 1
Iespējas:
tukšums*buff- rādītājs uz buferi, kurā tiek glabāti nolasītie dati
WORD btr- nolasāmo baitu skaits
VĀRDS*br- rādītājs uz mainīgo, kas saglabā nolasīto baitu skaitu.
Atgriešanas vērtības:
FR_OK (0)- atdod sekmīgas funkcijas izpildes gadījumā
FR_DISK_ERR- diska kļūda
FR_NOT_OPENED- fails netika atvērts
FR_NOT_ENABLED- disks nav uzstādīts
FATFS fs;//deklarē FATFS BYTE tipa objektu buff;//buferis faila lasīšanai WORD br; // baitu skaitītājs lasīt // pievienot disku if (pf_mount(&fs) == FR_OK) ( // atvērt failu, kas atrodas saknes direktorijā if(pf_open("hello.txt") == FR_OK) ( // lasīt 10 baiti no tā pf_read(buff, 10, &br); if(br != 10) ( //ja br nav vienāds ar 10 //tas nozīmē, ka esam sasnieguši faila beigas ) ) )
FRESULT pf_write(const void* buff, WORD btw, WORD* bw)- funkcija ļauj ierakstīt datus atvērtā failā. Lai funkcija darbotos failā pffconf.h, jums ir jāraksta
#define _USE_WRITE 1
Iespējas:
tukšums*buff- rādītājs uz buferi, kuru vēlamies rakstīt, nulles vērtība pabeidz rakstīšanu
WORD btw- baitu skaits, ko vēlamies rakstīt
WORD*bw- rādītājs uz mainīgo, kas saglabā ierakstāmo baitu skaitu. Analizējot šo mainīgo, varat uzzināt, vai ir sasniegts faila beigas.
Atgriešanas vērtības:
FR_OK (0)- atdod sekmīgas funkcijas izpildes gadījumā
FR_DISK_ERR- diska kļūda
FR_NOT_OPENED- fails netika atvērts
FR_NOT_ENABLED- disks nav uzstādīts
Sakarā ar to, ka bibliotēka ir paredzēta mikrokontrolleriem ar nelielu atmiņas apjomu, šai funkcijai ir vairāki ierobežojumi:
- jūs nevarat izveidot jaunus failus, un jūs varat rakstīt tikai esošajos
- faila lielumu nevar palielināt
- nevar atjaunināt laikspiedolu
- rakstīšanas darbību var sākt/apturēt tikai pie sektora robežas
- tikai lasāms faila atribūts nevar novērst rakstīšanu
Lai saprastu priekšpēdējo punktu, jāzina, ka kartes atmiņa ir sadalīta blokos (sektoros) pa 512 baitiem un ierakstīšanu var sākt tikai no sektora sākuma. Tādējādi, ja mēs vēlamies ierakstīt 1000 baitus, tad pirmais sektors tiks ierakstīts pilnībā, un tikai 488 baiti tiks ierakstīti otrajā, bet atlikušie 24 baiti tiks aizpildīti ar nullēm.
Lai rakstītu atvērtā failā, rīkojieties šādi:
- iestatiet rādītāju uz sektora robežu, ja tas nav iestatīts uz robežu, rādītājs tiks noapaļots līdz apakšējai sektora robežai
- izsauciet rakstīšanas funkciju vajadzīgo reižu skaitu
- pabeidziet ierakstu, izsaucot funkciju ar nulles rādītāju
Lai sniegtu ierakstīšanas funkcijas darbības piemēru, ir jāapsver vēl viena funkcija.
FRESULT pf_lseek(DWORD nobīde)- iestata lasīšanas/rakstīšanas rādītāju uz atver failu. Varat iestatīt rādītāju ar absolūtu vai relatīvu nobīdi; absolūtai nobīdei funkcijai ir jānodod skaitlis
pf_lseek(5000);
attiecībā uz relatīvo, nododiet rādītāja vērtību pašreizējai pozīcijai fs.fptr un nobīdes apjoms
pf_lseek(fs.fptr + 3000);
Lai funkcija darbotos failā pffconf.h, jums ir jāraksta
#define _USE_LSEEK 1
Iespējas:
DWORD nobīde ir baitu skaits, uz kuru pārvietot rādītāju.
Atgriešanas vērtības:
FR_OK (0)- atdod sekmīgas funkcijas izpildes gadījumā
FR_DISK_ERR- diska kļūda
FR_NOT_OPENED- fails netika atvērts
Datus failā var ierakstīt šādā veidā.
FATFS fs;//deklarē FATFS BYTE tipa objektu buff;//buferis faila lasīšanai WORD br; // baitu skaitītājs lasa // pievieno disku if (pf_mount(&fs) == FR_OK) ( // atver failu, kas atrodas saknes direktorijā if(pf_open("hello.txt") == FR_OK) ( // set rādītājs uz pirmo sektoru pf_lseek(0); //write pf_write(buff, 10, &br); //pabeidz rakstīšanu pf_write(0, 0, &br); ) )
Es arī atstāju šeit patiešām strādājoša koda daļu, kas izmanto visas iepriekš aprakstītās funkcijas.
#define F_CPU 8000000UL #define buff_size 10 #include
FRESULT pf_opendir(DIR* dp, const char * ceļš)- funkcija atver esošu direktoriju un izveido rādītāju uz DIR tipa objektu, kas tiks izmantots, lai iegūtu failu sarakstu atvērtajā direktorijā.
Lai funkcija darbotos failā pffconf.h, jums ir jāraksta
#define _USE_DIR 1
Iespējas:
DIR *dp- rādītājs uz DIR tipa mainīgo.
const char *ceļš- norādiet uz virkni, kas satur ceļu uz direktoriju, direktorijus atdala ar slīpsvītru
Atgriešanas vērtības:
FR_OK (0)- atdod sekmīgas funkcijas izpildes gadījumā
FR_NO_PATH- nevarēja atrast ceļu
FR_NOT_READY- Neizdevās inicializēt disku
FR_DISK_ERR- diska kļūda
FR_NOT_ENABLED- disks nav uzstādīts
//mainīgo lielumu deklarēšana FATFS fs; DIR rež.; //mount disks pf_mount(&fs); //atvērt direktoriju pf_opendir(&dir, "MY_FOLDER");
FRESULT pf_readdir (DIR* dp, FILINFO* fno)- funkcija ļauj lasīt direktorijas saturu. Lai to izdarītu, atveriet direktoriju ar funkciju pf_opendir () un izsauciet pf_readdir (). Katru reizi, kad funkcija tiek izsaukta, tā atgriezīs objekta (mapes/faila) nosaukumu, kas atrodas norādītajā direktorijā. Kad tas ir izgājis cauri visiem objektiem, tas atgriezīs nulles virkni masīva elementā fno.fname.
Lai funkcija darbotos failā pffconf.h, jums ir jāraksta
#define _USE_DIR 1
Iespējas:
DIR *dp- rādītājs uz DIR tipa mainīgo, kas iepriekš jādeklarē
FILINFO *fno- rādītājs uz FILINFO tipa mainīgo, kas iepriekš jādeklarē.
Atgriešanas vērtības:
FR_OK- sekmīga funkcijas izpilde
FR_DISK_ERR- diska kļūda
FR_NOT_OPENED- direktorijs nav atvērts
FATFS fs; FRESULT rez. FILINFO fno; DIR rež.; //mount disks pf_mount(&fs); //atvērt direktoriju res = pf_opendir(&dir, MY_FOLDER); //izlasiet direktorijas saturu for(;;)( res = pf_readdir(&dir, &fno); //pārbaudiet, vai lasīšanas laikā nav bijušas kļūdas // un vai norādītajā direktorijā joprojām ir faili if ((res ! = FR_OK) || ( fno.fname == 0))( break; ) //parādīt ērtā veidā fno.fname usart_sendStr(fno.name); usart_sendStr(/r); )
Un visbeidzot es atstāšu darba projektu šeit
33. nodarbība
1. daļa
SPI. SD karte. TAUKI
Šodien mēs turpināsim savu iecienītāko tēmu par SPI interfeisu. Mēs pabeidzām ar šo autobusu viens otram kontrolieriem Atmega8a un ATTtiny2313. Un šodien mēs mēģināsim savienot atmiņas karti ar mikrokontrolleru, izmantojot šo kopni, izmantojot šo interfeisu SD (Secure Digital).
Šo karti var pieslēgt arī caur SDIO interfeisu, taču, tā kā mūsu kontrollera aparatūra šādu interfeisu neatbalsta, tad šajā nodarbībā to neaiztiksim. Mūs interesē autobusa pieslēguma veids SPI, jo mums jau ir labas uzkrātās zināšanas par šo tēmu, kā arī aparatūras atbalsts mūsu programmējamajā kontrollerī.
Tomēr mēs redzēsim abu veidu karšu kāju izgriezumus.
Nu, tā kā mūs interesē otrais veids, mēs ar to tiksim galā.
Un te īsti nav ko saprast. Visi šie saīsinājumi mums ir zināmi. Šeit ir visas SPI interfeisa standarta kājas, un šeit nav nekā lieka.
Tagad par karti kopumā. Šī karte ļauj mums uzglabāt datus, tās atmiņas veids ir FLASH, kas, salīdzinot ar EEPROM tipa atmiņu, arī ir nepastāvīgs, tas ir, atslēdzot strāvu, dati nekur nepazūd, bet paliek saglabāti. Tāpat šai atmiņai ir atšķirības, ar tām iepazīsimies programmēšanas procesā. Viena no galvenajām atšķirībām ir tāda, ka šajā atmiņā nevar ierakstīt vienu baitu, kā tas ir EEPROM atmiņā. Teorētiski, protams, varam, bet tur tiks ierakstīti tikai vieni no mūsu baita vai tikai nulles, atkarībā no FLASH veida - NOR vai NAND. Tas ir, pirms baita rakstīšanas jums tas ir jāizdzēš, un šīs atmiņas organizācijas dēļ mēs varam dzēst tikai blokos un tāpēc rakstīt tikai blokos. Bet ir vislielākā atšķirība no EEPROM - tā ir cena. Tas ir daudzkārt lētāks, pat dažkārt par lielumu par vienu saglabāto informācijas vienību (par megabaitu, par gigabaitu). Tāpēc FLASH atmiņā parasti ir daudz lielāks informācijas apjoms.
Ir 4 SD veidi, taču mēs to pētīsim nedaudz vēlāk.
Savienosim šo karti atrodoties proteusā
Šeit viss ir vienkārši. Patiesībā ne gluži tā. Vajag vairāk rezistoru
Šie rezistori ir nepieciešami, lai nodrošinātu atbilstošus līmeņus, jo karte tiek darbināta ar 3,3 voltiem. Kopumā saskaņā ar tehnisko dokumentāciju no 2,7 līdz 3,6 voltiem.
Arī tas proteusā nav norādīts, bet patiesībā mēs savu karti darbināsim no atsevišķa barošanas avota, uzstādot mikroshēmu, kas pārvērš 5 voltus uz 3,3 voltiem.
Drīzāk mēs neko neinstalēsim, bet izmantosim gatavu moduli, kurā viss jau ir uzstādīts.
Mums ir arī pievienots displejs, piemēram, paplašinot displeja bibliotēkas funkcionalitāti.
Tā tas izskatās praksē
Šādi izskatās modulis ar turētāju
Tādu moduli var atrast visur, maksā santīmu. Modulis, kas savieno, izmantojot SDIO, maksā vairāk. Mēs arī redzam, ka modulī jau ir uzstādīta mikroshēma, lai pazeminātu spriegumu līdz 3,3 voltiem. Un mēs pieslēdzam strāvu tikai 5 voltu kontaktam, un neko nepievienojam 3.3
Tāpat modulī ir uzstādīti visi līmeņu dalītāji, tas ir, šis modulis ir īpaši paredzēts savienojumam ar 5 voltu ierīcēm.
Un es izraku zibatmiņas karti testiem 32 megabaitu, tieši megabaitu nevis gigabaitu.
Šī zibatmiņas karte tika uzdāvināta kopā ar kaut kādu fotoaparātu un tā mums vislabāk derēs mūsu testiem, vismaz nedomāsim, ka mums ir tāda vai tāda kļūme dēļ pārāk lielas atmiņas kartes.
Kods arī tika ņemts no pēdējās nodarbības kopā ar displeja bibliotēku, jo ļoti aktīvi izmantosim pēdējā nodarbībā izveidoto funkciju, tikai protams tika izveidots jauns projekts un attiecīgi nosaukts MYSD_SPI.
Izdzēsiet nevajadzīgās rindas, galvenajā () mums būs tikai tas
starptgalvenais( nederīgs)
neparakstītsstarpti;
Port_ini();
LCD_ini(); //inicializēt displeju
clearlcd(); //notīrīt displeju
setpos(0,0);
str_lcd( "1. virkne");
setpos(2,1);
str_lcd( "string2");
setpos(4,2);
str_lcd( "virkne 3");
setpos(6,3);
str_lcd( "virkne 4");
Delay_ms(2000);
// priekš (i=0;i<=22;i++) {str80_lcd(buffer2+i*20);_delay_ms(1000);}
Kamēr(1)
Tā kā mēs nerādīsim tekstu pēc rakstzīmes, tad mainīgajā varēs iztikt ar char veidu
neparakstītschar i;
Tagad vēl viena nianse.
Lai mēs Proteus varētu strādāt ar SD karti, nepietiek tikai ar turētāju pievienot pašu karti, tā rekvizītos jāpievieno arī flash kartes attēla fails.
To izveidot nav grūti. Viens veids ir to izveidot, izmantojot programmu WinImage.
Mēs tajā parasti izveidojam jaunu failu, izmantojot izvēlnes vienumu Fails -\u003e Jauns. Dialoglodziņā atlasiet pēdējo vienumu un noklikšķiniet uz "OK"
Testam Proteus mums pilnīgi pietiek ar 4 megabaitu lielumu, tāpēc nākamajā dialoglodziņā mainīsim lauku ar sektoru skaitu, kā arī atlasīsim formātu FAT12 / 16, jo ar 32 bitu failu sistēma nedaudz atšķirīgu darba specifiku, kā arī noklikšķiniet uz "OK"
Kopumā, protams, varam atstāt arī FAT32, jo ar failu sistēmu vēl nestrādājam, bet turpmākajās nodarbības daļās strādāsim ar failu sistēmu un strādāsim ar 12/16.
Pēc tam mēs saglabājam izveidoto failu, izmantojot izvēlnes vienumu Fails -> Saglabāt kā. Un mēs to saglabājam mapē, kurā mums ir saglabāts proteus projekts. Nosauciet failu un noklikšķiniet uz "Saglabāt"
Kā arī tad būs jāpārliecinās, vai mēs neesam ieguvuši šo failu ar "tikai lasāms" atribūtu, un pēc tam jau varam to savienot proteusā. Faila nosaukums būs jāievada manuāli, jo proteusam ir nepieciešams kaut kāds savs formāts un mūsu fails vienkārši nebūs redzams
Mums nav nepieciešams ceļš, jo mums ir fails projekta mapē. Mēs nospiežam "OK".
Mums nav nepieciešams inicializēt kopni, jo mums būs programmatūras SPI, ne visas zibatmiņas kartes darbojas pareizi ar aparatūras zibatmiņas kartēm, tad mums nebūs jāizmanto nekādi reģistri. Protams, aparatūras ir labākas, bet, lai kārtīgi izprastu protokola darbību, ir jāstrādā arī ar programmatūru, tas ir, jārauj portiem kājas. Kopumā paskatoties uz diagrammu, var likties, ka mums viss ir aparatūrā, jo es izvēlējos tieši šādas kājas, tas ir tāpēc, ka es to vienkārši izvēlējos, lai vēlāk, kādreiz, varbūt kāds tomēr mēģinās strādāt ar aparatūras ieviešanas riepām .
Pievienojiet makro aizstāšanu portu tapām
#iekļauts"galvenais.h"
#definētMOSI3
#definētMISO4
#definētSCK5
#definētSS2
Pievienosim porta inicializācijas funkcijai kāju inicializācijas kodu
nederīgsport_ini( nederīgs)
PORTD=0x00;
DDRD=0xFF;
PORTB|=(1<< SS)|(1<< MISO)|(1<< MOSI);
DDRB|=(1<< SS)|(1<< MOSI)|(1<< SCK);
Mēs atstājam MISO kāju ieejā, jo pēc noklusējuma visi reģistra biti ir nulle, un mēs tai vienkārši nepieskaramies. Mēs arī nekavējoties ieslēdzam augstu līmeni MOSI un SS un uzvelkam rezistoru uz MISO.
Uzrakstīsim funkciju baita pārsūtīšanai pa SPI kopni
nederīgsSPI_SendByte( neparakstītscharbaits)
{
}
Pievienojiet mainīgo cilpai un pašai cilpai
nederīgsSPI_SendByte( neparakstītscharbaits)
neparakstītschari;
priekš( i=0; i<8; i++) // pārvietoties pa baita bitiem
{
}
Es domāju, ka ir saprotams, kāpēc mēs skaitam līdz 8, jo mēs pārraidām tieši 8 bitus.
Nu, sāksim nodot viņiem garām viltīgi.
Vispirms pārbaudīsim galējo kreiso bitu, atlasot to no visa baita ar maskēšanu, un, ja mums tas ir vienāds ar 1, tad MOSI kopnē iestatīsim to uz 1, un ja 0, tad kopnei nepieskaramies.
priekš( i=0; i<8; i++) // pārvietoties pa baita bitiem
Laba diena visiem! Šodien mēs runāsim par pievienojot SD atmiņas karti uz STM32 mikrokontrolleri.
Šķiet, ka STM32F10x kontrolleriem ir daudz atmiņas, kāpēc ir vēl viena, bet šis iespaids ir maldinošs) Piemēram, mums displejā jāparāda pāris dažādi attēli - 320 * 240 formātā - tas ir, 76800 pikseļi, no kuriem katrs atbilst pat 2 baitiem. Tātad mēs iegūstam apmēram 150 kB uz vienu attēlu. Un tas ir daudz pēc mikrokontrollera standartiem, un tas nav fakts, ka tā zibatmiņā var ievietot divus dažādus attēlus. Vai arī mums ir jāsaglabā liels informācijas apjoms, piemēram, dati no kāda sensora. Turklāt, lai šie dati būtu pieejami arī pēc strāvas izslēgšanas. Šeit noder ārējā atmiņa. Un lielisks risinājums SD atmiņas karte vai MMC. Starp citu, šajā rakstā mēs veiksim eksperimentus micro SD karte.
Pirmkārt, daži vārdi par pašu atmiņas karti vai drīzāk par tās spraudni. Viss izskatās šādi:
Kas tad mums šeit ir? Nu uzreiz var redzēt, ka viņai ir pat astoņi secinājumi. Tapu piešķiršana ir šāda (no kreisās uz labo):
Kolonna SPI Mode mums norāda, ka tā mijiedarbojas ar mikrokontrolleri, izmantojot SPI interfeisu. BET! Mēs iesim citu ceļu 😉 Lieta tāda, ka STM32 ir jau gatavs perifērijas modulis darbam ar atmiņas kartēm, un to sauc par SDIO.
Parasti mijiedarbība ar atmiņas kartēm sastāv no noteiktu komandu pārsūtīšanas uz tām. Dažām komandām ir nepieciešams arguments, dažām nav. Komandas ir atrodamas konkrētas kartes oficiālajā dokumentācijā. Tātad iebūvētais SDIO modulis ļauj ievērojami vienkāršot komandu pārsūtīšanas procesu un patiešām arī darbu ar ārējām atmiņas kartēm. Piemēram, šeit ir reģistrs SDIO_CMD- tur mēs vienkārši pierakstām komandas kodu, kuru vēlamies pārsūtīt uz karti. Vai arī šeit ir statusu reģistrs SDIO_STA- katrai šķaudīšanai ir pat 24 karogi, tas ir, lielam skaitam pasākumu.
Starp citu, STM priecē arī laba dokumentācija visai lietai. Šeit, piemēram, ir detalizēts SD atmiņas kartes inicializācijas apraksts (viss ir aprakstīts līdzīgi citiem karšu veidiem):
Patiesībā ir pienācis laiks pāriet pie praktiska piemēra. Iedziļināsimies standarta perifērijas bibliotēkā.
Failā stm32f10x_sdio.h tradicionāli mēs atrodam struktūras visu veidu iestatījumiem - tas ir, lai atlasītu pulksteņa signāla avotu, SDIO kontrollera frekvenci un pielāgotu pārraidīto baitu skaitu. Tur viss ir tik dāsni komentēts, ka pat negribas to atsevišķi atkārtot)) Paskatieties:
| typedef struct ( uint32_t SDIO_ClockEdge; /* Norāda pulksteņa pāreju, kurā tiek veikta bitu uztveršana. Šis parametrs var būt @ref SDIO_Clock_Edge vērtība */ uint32_tSDIO_ClockBypass; /* Norāda, vai SDIO pulksteņa dalītāja apiešana ir iespējota vai atspējota. Šis parametrs var būt @ref vērtība SDIO_Clock_Bypass */ uint32_tSDIO_ClockPowerSave; /* Norāda, vai SDIO pulksteņa izvade ir iespējota vai atspējota, kad kopne ir dīkstāvē. Šis parametrs var būt @ref vērtība SDIO_Clock_Power_Save */ uint32_tSDIO_BusWide; /* Norāda SDIO kopnes platumu. Šis parametrs var būt @ref SDIO_Bus_Wide vērtība */ uint32_t SDIO_HardwareFlowControl; /* Norāda, vai SDIO aparatūras plūsmas vadība ir iespējota vai atspējota. Šis parametrs var būt @ref vērtība SDIO_Hardware_Flow_Control */ uint8_tSDIO_ClockDiv; /* Norāda SDIO kontrollera pulksteņa frekvenci. Šis parametrs var būt vērtība no 0x00 līdz 0xFF. */) SDIO_InitTypeDef; typedef struct ( uint32_t SDIO_Arguments; /* Norāda SDIO komandas argumentu, kas tiek nosūtīts uz karti kā daļa no komandas ziņojuma. Ja komanda satur argumentu, tā ir jāielādē šajā reģistrā pirms komandas ierakstīšanas komandu reģistrā */ uint32_t SDIO_CmdIndex; /* Norāda SDIO komandas indeksu. Tam ir jābūt mazākam par 0x40. */ uint32_t SDIO_Response; /* Norāda SDIO atbildes veidu. Šis parametrs var būt @ref vērtība SDIO_Response_Type */ uint32_tSDIO_Pagaidiet; /* Norāda, vai SDIO gaidīšanas pārtraukuma pieprasījums ir iespējots vai atspējots. Šis parametrs var būt @ref vērtība SDIO_Wait_Interrupt_State */ uint32_t SDIO_CPSM; /* Norāda, vai SDIO komandu ceļa stāvokļa mašīna (CPSM) ir iespējota vai atspējota. Šis parametrs var būt @ref SDIO_CPSM_State vērtība */) SDIO_CmdInitTypeDef; typedef struct ( uint32_t SDIO_DataTimeOut; /* Norāda datu taimauta periodu kartes kopnes pulksteņa periodos. */ uint32_tSDIO_DataLength; /* Norāda pārsūtāmo datu baitu skaitu. */ uint32_tSDIO_DataBlockSize; /* Norāda datu bloka izmēru bloku pārsūtīšanai. Šis parametrs var būt @ref vērtība SDIO_Data_Block_Size */ uint32_tSDIO_TransferDir; /* Norāda datu pārsūtīšanas virzienu neatkarīgi no tā, vai pārsūtīšana ir lasīšana vai rakstīšana. Šis parametrs var būt @ref SDIO_Transfer_Direction vērtība */ uint32_tSDIO_TransferMode; /* Norāda, vai datu pārsūtīšana notiek straumes vai bloķēšanas režīmā. Šis parametrs var būt @ref SDIO_Transfer_Type vērtība */ uint32_t SDIO_DPSM; /* Norāda, vai SDIO datu ceļa stāvokļa mašīna (DPSM) ir iespējota vai atspējota. Šis parametrs var būt @ref SDIO_DPSM_State vērtība */) SDIO_DataInitTypeDef; |
Ņemiet vērā, kā SPL īsteno komandu pārsūtīšanu uz atmiņas karti. Šiem nolūkiem ir izveidota atsevišķa struktūra. SDIO_CmdInitTypeDef. Laukā SDIO_CmdIndex laukā ievadiet komandas kodu SDIO_arguments- komandas arguments, aizpildiet arī atlikušos laukus. Atliek kaut kā iespiest šos datus micro SD kartē 😉 Un šim nolūkam mēs esam sagatavojuši funkciju:
SDIO_SendCommand (SDIO_CmdInitTypeDef *SDIO_CmdInitStruct)
Kā argumentu mēs tam nododam to pašu struktūru, ko izveidojām. Ir datu rakstīšanas funkcija - SDIO_WriteData(uint32_tData). Pēc šīs funkcijas izsaukšanas dati būs īpaši izveidotā reģistrā - SDIO_FIFO.
Šādi tiek veikts darbs ar SDIO moduli STM32F10x)
Tagad beidzot pāriesim pie prakses. Es atkal strādāšu ar Mini STM32 plati, jo labie ķīnieši bija neizpratnē, uzstādot tajā micro SD atmiņas kartes slotu. Šeit ir diagramma kartes savienotāja savienošanai ar mikrokontrolleru: 
Lai uzrakstītu programmu, mēs izmantosim gatavu piemēru Keil - no turienes nozagsim divus failus, kuros ir ieviests kaut kas līdzīgs draiverim darbam ar kartēm - tie ir faili sdcard.c Un sdcard.h Mēs izveidojam jaunu projektu, saistām tur šos failus un papildus, protams, CMSIS un SPL failus. Šeit ir pabeigts projekts, kurā viss jau ir pievienots - atliek tikai uzrakstīt galvenās () funkcijas kodu)
Fails sdcard.c realizē visdažādākās funkcijas darbam ar atmiņas karti, tagad atliek tikai tās izmantot 😉 Rakstam kodu! Piemēram, ierakstīsim 512 baitus testa datu uz micro SD un pēc tam mēģināsim tos nolasīt:
| // Nepieciešamo failu saistīšana#include "stm32f10x.h" #include "sdcard.h" /*******************************************************************/ // Ievades un izvades datu masīvi un mainīgais datu glabāšanai// par mūsu karti uint8_t writeBuffer[ 512 ] ; uint8_t readBuffer[512] ; SD_CardInfo SDCardInfo; /*******************************************************************/ int main() ( // Pārbaudīt ierakstāmos datus for (uint16_t i = 0 ; i< 512 ; i++ ) { writeBuffer[ i] = i % 256 ; readBuffer[ i] = 0 ; } // Kartes inicializācija SD_Init() ; // Iegūstiet kartes informāciju SD_GetCardInfo(& SDCardInfo) ; // Kartes izvēle un darbības režīma iestatīšana SD_SelectDeselect((uint32_t ) (SDCardInfo.RCA<< 16 ) ) ; SD_SetDeviceMode(SD_POLLING_MODE) ; // Un visbeidzot rakstīšana un lasīšana SD_WriteBlock(0x00 , rakstīšanas buferis, 512 ); SD_ReadBlock(0x00 , lasīšanas buferis, 512 ); kamēr (1 ) ( ) ) /*******************************************************************/ |
Lūdzu, ņemiet vērā, ka SD karte atbalsta rakstīšanu 512 baitu blokos.
Ja programmu palaižam zem atkļūdotāja, redzēsim, ka nolasītie dati atbilst rakstītajiem =) Tātad eksperimentu var uzskatīt par veiksmīgu. Ar to šodiena ir beigusies, uz drīzu tikšanos!
Mihails Russkihs
Sniegta īsa informācija par SD kartēm, sniegti SD kopnes darbības pamati, izskaidrota stm324xg_eval_sdio_sd draivera lietošanas kārtība, kas paredzēts STM32 saimes mikrokontrolleru komunikācijas vienkāršošanai ar SD kartēm.
Dažām iegultajām sistēmām jāspēj uzglabāt lielu informācijas apjomu. Piemēram, dažādu fizisko lielumu un parametru (strāvas, sprieguma, temperatūras, ģeogrāfiskās koordinātes) reģistratoriem no sensoriem saņemtie rādījumi jāsaglabā noteiktā datu nesējā, ko vēlāk varētu izņemt no ierīces un savienot ar datoru, lai skatītu datus. lietotājam draudzīgā formā. Lai atrisinātu šo problēmu, šķiet, ka visredzamākais ir USB zibatmiņu izmantošana. Tie ir plaši izplatīti tirgū un ļauj uzglabāt lielu informācijas apjomu. Bet dažām mazām iegultajām sistēmām kompaktums ir vissvarīgākais, un šie diskdziņi var būt pārāk lieli. Turklāt ne visi mikrokontrolleri ir aprīkoti ar USB moduli, un sistēmas izstrādātājs var pavadīt diezgan daudz laika, strādājot ar USB steku, kas var palielināt projekta laiku. Šajā ziņā laba alternatīva USB ir SD karšu izmantošana, kas ir ļoti kompaktas un ļauj apmainīties ar datiem, izmantojot kopējo SPI interfeisu vai speciālu interfeisu SD kartēm.
SD (Secure Digital) atmiņas kartes ir paredzētas galvenokārt lietošanai pārnēsājamās ierīcēs. Mūsdienās tirgū ir liels skaits modeļu, ko nodrošina tādi uzņēmumi kā SanDisc un kas var ierakstīt datus no 8 MB līdz 2 TB ar ātrumu, kas atkarīgs no klases. SD kartēm, atšķirībā no MMC kartēm, papildus ierastajai datu glabāšanas zonai ir speciāla aizsargāta zona, kas nav pieejama parastam lietotājam. Lai ierīce varētu nolasīt SD kartē ierakstīto informāciju failu veidā, šai kartei ir jābūt noteiktai failu sistēmai. Šajā gadījumā vispiemērotākā sistēma ir FAT sistēma, jo SD karšu rakstīšanas / lasīšanas ciklu skaits ir ierobežots, un sistēmām, piemēram, NTFS un ext, tiek reģistrēti žurnāli, tas ir, tie ietver biežu aptauju.
Datu pārraide un saņemšana tiek veikta, izmantojot SPI interfeisu vai SD kopni. 1. attēlā parādīti dažādu veidu SD karšu tapu piešķiršanas veidi, un 1. tabulā parādīta šo tapu funkcionalitāte.
| 1. tabula. | SD kartes tapu funkcionālais mērķis | ||||||||||||||||||||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||||||||||||||||||||
Lai gan resursdatora kontrolleris var sazināties ar karti, izmantojot SPI, SD kopne joprojām nodrošina vairāk iespēju un ļauj pārsūtīt informāciju ar lielāku ātrumu, jo ir četras datu līnijas. Tāpēc tālāk mēs sīkāk apsvērsim tieši šo metodi darbam ar SD karti.
Datu pārsūtīšana caur SD kopni
Sakari ar SD karti notiek pa 6 informācijas līnijām: 4 datu līnijām (DAT0, DAT1, DAT2, DAT3), sinhronizācijas līnijām (CLK), komandu pārraides līnijām (CMD). Kad tas ir savienots ar kontrolieri, datu līnija un komandrinda ir jāpievelk pie strāvas, kā parādīts 2. attēlā.
Datu rakstīšana un lasīšana tiek veikta bloku pēc bloka. Parasti bloks sastāv no 512 baitiem. Datu un pakalpojumu informācijas pārsūtīšanas pamatā ir "komandu un atbildes" mijiedarbības modelis. Pirms datu pārsūtīšanas vai saņemšanas saimniekdatoram ir jānosūta atbilstošā komanda CMD līnijā. No SD kartes jānāk atbildei tajā pašā rindā, pēc kuras var veikt nepieciešamo darbību. SD standarts atbalsta vairāku vergu klātbūtni kopnē, un tādā gadījumā resursdatora kontrolleris var nosūtīt komandas, izmantojot apraidi. Komandai ir skaidra struktūra, kas sastāv no 48 bitiem: 1 sākuma bits, 1 pārraides bits (iestatīts uz 1), 6 biti komandas indeksam, 32 biti argumentam, 7 biti kontrolsummai un 1 beigu bits. Atbildei var būt tāda pati 48 bitu struktūra (tādā gadījumā pārraides bits ir iestatīts uz 0) vai sastāv no 136 bitiem (tā sauktais garās atbildes formāts): 1 sākuma bits, 1 pārraides bits (iestatīts uz 0), 6 rezervēti biti , 127 biti CID (Card Identification Register) vai CSD (Card Specific Data Register) satura un kontrolsumma, 1 pieturas bits.
Sākot darbu ar karti, saimniekdatora kontrolieris pārlādē karti, izmantojot komandas GO_IDLE_STATE(CMD0) Un IO_RW_DIRECT (CMD52). Pilns komandu saraksts ar aprakstiem ir atrodams (A pielikumā). Pēc atsāknēšanas karte atjaunos noklusējuma iestatījumus, un tās adrese būs vienāda ar RCA = 0x0001. Ja resursdatoram ir pievienotas vairākas kartes, tad izmantojot komandu SET_RELATIVE_ADDR (CMD3) tā katrai kartei piešķir savu adresi. Tāpat darba sākumā tiek pārbaudīts kartei pievienotais spriegums. Kartes spriegumam jābūt stingri noteiktā diapazonā no 2,7 līdz 3,6 V. Šajā sakarā saimniekdatora kontrolieris, izmantojot komandu SEND_OP_COND (CMD1 vai ACMD41) jānoskaidro kartes strāvas spriegums un jāpārtrauc darbs ar to, ja tas nav vajadzīgajā diapazonā. Šis ir vispārējais kartes inicializācijas princips, kuram atkarībā no kartes veida (MMC, SD, SD I / O) var izmantot citas komandas un papildu darbības, tāpēc, ieviešot zema līmeņa saskarni, jums ir nepieciešams uzmanīgi izlasiet kartes dokumentāciju un izpētiet CMD komandas.
Rakstīšanas laikā resursdators nosūta uz karti vienu vai vairākus blokus, izmantojot komandu WRITE_BLOCK (CMD24) vai WRITE_MULTIPLE_BLOCK (CMD25), attiecīgi, savukārt katra bloka beigās saimniekdators ieraksta kontrolsummu. Karte, kurai ir iespējota rakstīšana, vienmēr varēs saņemt bloku(-us), bet, ja kontrolsumma nesakrīt, karte ziņos par kļūdu un neierakstīs pašreizējo bloku savā atmiņā, un pārsprāgšanas gadījumā šādi bloki tiks ignorēti.
Varat arī pārsūtīt informāciju resursdatoram, tas ir, lasīt, vienā blokā, izmantojot komandu READ_SINGLE_BLOCK (CMD17) vai vairāku bloku partija, izmantojot komandu READ_MULTIPLE_BLOCK (CMD18). Sērijveida pārraides gadījumā resursdators var pārtraukt lasīšanu jebkurā laikā, nosūtot komandu STOP_TRANSMISSION (CMD12). Ja vairāku bloku pārsūtīšanas laikā kartes iekšējais kontrolieris izlabo kļūdu, tas pārtrauks datu sūtīšanu uz saimniekkontroli, bet atstās karti datu pārsūtīšanas režīmā. Šajā gadījumā resursdatoram būs jāpiespiež lasīšana beigties ar komandu CMD12, savukārt, atbildot uz šo komandu, karte ziņos par lasīšanas kļūdu.
SD kopnes pareizas darbības organizēšana ir diezgan darbietilpīgs process, jo papildus iepriekš aprakstītajām vispārīgajām situācijām ir jāparedz dažādas kartes darbības nianses un jāievieš papildu kļūdu apstrādātāji. Tāpēc racionālākais risinājums būtu izmantot īpašas bibliotēkas, kas ļauj izstrādātājam neiedziļināties datu pārsūtīšanas detaļās aparatūras līmenī un ievērojami samazināt izstrādes laiku. Viena no šīm bibliotēkām, kas tiks apspriesta turpmāk, ir draiveru bibliotēka. stm324xg_eval_sdio_sd populāriem mikrokontrolleriem, kas ļauj ievērojami vienkāršot darbu ar SDIO moduli, kas paredzēts mijiedarbībai ar SD kartēm.
stm324xg_eval_sdio_sd draiveri
Šis draiveris ir funkciju bibliotēka, ar kuras palīdzību jūs varat ieviest augsta līmeņa saskarni saziņai ar SD karti. Draiveris tiek piegādāts darbam ar STM324VG atkļūdošanas plati (UtilitiesSTM32_EVALSTM3240_41_G_EVAL), taču pēc funkciju maiņas, kas saista šo bibliotēku ar zema līmeņa SDIO interfeisu, tas var darboties ar daudziem STM32 saimes mikrokontrolleriem, kas ietver SDIO moduli. No iepriekšējā teikuma izriet, ka projektā jāiekļauj faili no standarta bibliotēkas Standarta perifērijas bibliotēka, kas nodrošina SDIO moduļa darbību zemā līmenī. Piemēram, STM32F4xx sērijas mikrokontrolleriem tie būs faili stm32f4xx_sdio.c Un stm32f4xx_sdio.h.
Pirms draivera funkciju izmantošanas programmētājam šis draiveris ir jāsaista ar aparatūru, tas ir, jākonfigurē SDIO moduļa līnijas. Lai to izdarītu, viņam ir jāizveido funkcijas savas programmas galvenajā failā main.c SD_LowLevel_Init() (lai iespējotu SDIO moduli) un SD_LowLevel_DeInit() (lai atspējotu SDIO moduli), kurā šīs līnijas ir jākonfigurē. Ja programmētājs vēlas izmantot tiešās atmiņas piekļuves moduli, lai palielinātu darba ātrumu ar SD karti, tad viņam būs jāizveido arī funkcijas SD_LowLevel_DMA_TxConfig() Un SD_LowLevel_DMA_RxConfig() atbild par datu pārraidi un saņemšanu, izmantojot PDP moduli. Kā piemēru četru norādīto funkciju inicializācijai varam ņemt failā pieejamo kodu stm324xg_eval.c no (UtilitiesSTM32_EVALSTM3240_41_G_EVAL).
Tagad apskatīsim galvenās funkcijas darbam ar šī draivera nodrošināto SD karti. Lai inicializētu karti, ir jāizsauc funkcija SD_Init() , kas konfigurē SDIO moduli, atsaucoties uz SD_LowLevel_Init() , pārbauda SD kartes veidu, iegūst pakalpojumu informāciju no CID un CSD reģistriem, iestata datu pārraides ātrumu (24 MHz pēc noklusējuma) un iestata kopnes platumu (4 biti). Izmantojot funkcijas, varat nolasīt no kartes saņemtos datus SD_ReadBlock() (viena bloka lasīšanai) un SD_ReadMultiBlocks() (vairāku bloku lasīšanai). Lai ierakstītu datus kartē, izmantojiet funkcijas SD_WriteBlock() (viena bloka rakstīšanai) un SD_WriteMultiBlocks() (vairāku bloku rakstīšanai). Šīm lasīšanas un rakstīšanas funkcijām ir trīs argumenti: buferis(bufera mainīgais, kurā jāievieto lasīšanas un rakstīšanas dati), adrese(SD kartes atmiņas vietas adrese) un bloka_izmērs(vienmēr 512, jo šīs funkcijas darbojas tikai blokos, kuru garums ir 512 baiti). Lai izdzēstu noteiktu kartes atmiņas apgabalu, ir funkcija SD_Erase() . Tas izmanto startaddr un endaddr kā argumentus. Pirmais norāda tās atmiņas šūnas adresi, no kuras tiks sākta dzēšana, bet otrā norāda tās šūnas adresi, kurā tiks pabeigta dzēšana.
Datu pārsūtīšanu starp SDIO moduli un mikrokontrollera atmiņu var veikt gan parastajā veidā, izmantojot centrālo procesoru, gan caur tiešās atmiņas piekļuves bloku. Lai izvēlētos vajadzīgo režīmu, jums ir nepieciešams failā stm324xg_eval_sdio_sd.h komentāru vai rindiņu #define SD_POLLING_MODE(parastais režīms) vai līniju #define SD_DMA_MODE(PDP režīms). Pēc rakstīšanas vai lasīšanas šī funkcija ir jāizmanto SD_GetStatus() pārbaudiet, vai karte ir pabeigusi pašreizējo darbību un ir gatava jaunu datu saņemšanai vai sūtīšanai. Ja šī funkcija atgriež SD_TRANSFER_OK, pārsūtīšana ir veiksmīgi pabeigta, SD_TRANSFER_BUSY atgriež, ka pārsūtīšanas kanāls ir aizņemts, un SD_TRANSFER_ERROR atgriež pārsūtīšanas kļūdu. Visas šīs vērtības ir noteiktas struktūrā SDTransferState, ierakstīts stm324xg_eval_sdio_sd.h. Ja informācijas pārsūtīšana tika veikta caur PDP bloku, tad papildus ir jāpārbauda, vai PDP kontrolieris ir pabeidzis visas datu pārsūtīšanas darbības. Tas tiek darīts, izmantojot funkciju SD_ReadWaitOperation() . Ir arī vērts atzīmēt, ka pārsūtīšana caur DMA bloku beidzas ar pārtraukumu, tāpēc programmētājam ir jāorganizē funkciju izsaukums SD_ProcessIRQ() moduļa pārtraukumu apstrādātājā SDIO SDIO_IRQHandler() un funkciju izsaukums SD_ProcessDMAIRQ() pārtraukumu apstrādātājā DMA2 DMA2_Streamx_IRQHandler() .
Lai labāk izprastu, kā darbojas vadītājs stm324xg_eval_sdio_sd varat izmantot darba piemēru no mapes SDIOSDIO_uSDCard(ProjectSTM32F4xx_StdPeriph_ExamplesSDIO). Izmantojot šo testa programmu, varat izdzēst noteiktu kartes atmiņas apgabalu, ierakstīt datus uz noteiktu adresi, nolasīt datus uz to pašu adresi un pēc tam salīdzināt nosūtīto un saņemto informāciju. Saņemšanas bufera un nosūtīšanas bufera identitāte norāda, ka SDIO modulis, sakaru kopne un SD karte darbojas normāli.
Tādējādi mēs varam teikt, ka SD kartes ir cienīgi USB zibatmiņu konkurenti, ja runa ir par nelielu iegulto sistēmu projektēšanu, kurām nepieciešams liels datu uzglabāšanas apjoms. Jūs varat pārsūtīt informāciju no un uz karti, izmantojot SPI interfeisu vai SD kopni, kas ir paredzēta šim nolūkam un nodrošina augstu pārsūtīšanas ātrumu. Komunikācijas ieviešanu ar karti ievērojami atvieglo, izmantojot īpašus draiverus, kas atvieglo darbu ar aparatūru un piedāvā programmētājiem ērti lietojamas funkcijas. Bet diemžēl nejaušā secībā rakstītus datus nepieņems neviena operētājsistēma, piemēram, Windows, tāpēc nākamajā daļā tiks runāts par to, kā strādāt ar SD karti ar FAT failu sistēmu.
Avotu saraksts
SD un microSD kartes var ievērojami paplašināt Arduino projektu iespējas, kas strādā ar lielu datu apjomu: datu reģistrētāji, meteoroloģiskās stacijas, viedās mājas sistēmas. Arduino plates ir aprīkotas ar salīdzinoši nelielu iekšējo atmiņu, tikai līdz 4 kilobaitiem, ieskaitot gan zibatmiņu, gan EEPROM. Ar šo atmiņu nepietiks, lai ierakstītu lielu datu apjomu, it īpaši, ja dēlis pastāvīgi izslēdzas vai izslēdzas. Arduino SD kartes pievienošana kā ārējam diskam ļauj palielināt jebkuras informācijas uzglabāšanas vietu. Noņemamie SD diskdziņi ir lēti, viegli savienojami un ērti lietojami. Pareizs SD kartes savienojums ar Arduino tiks apspriests rakstā.
Darbs ar SD atmiņu arduino nav īpaši grūts. Vienkāršākais veids ir savienot gatavu moduli un izmantot standarta bibliotēku. Mēs sāksim ar šo iespēju.
Gatavā moduļa izmantošanai ir dažādas priekšrocības. Šis ir diezgan vienkāršs un ērts rīks darbam ar lielu datu apjomu. Tam nav nepieciešamas īpašas savienojuma prasmes, visi savienotāji ir parakstīti tieši uz tāfeles. Jums ir jāmaksā par ērtībām, taču moduļa izmaksas ir salīdzinoši zemas, to var viegli atrast par pieņemamām cenām Krievijas un ārvalstu tiešsaistes veikalos.
Universālais modulis ir parasta plate, uz kuras ir novietots kartes slots, rezistori un sprieguma regulators. Tam ir šādas tehniskās īpašības:
- Darba sprieguma diapazons 4,5-5 V;
- Atbalsta SD karti līdz 2GB;
- Strāva 80 mA;
- FAT 16 failu sistēma.
SD kartes modulis realizē tādas funkcijas kā informācijas glabāšana, nolasīšana un ierakstīšana kartē, kas nepieciešamas uz mikrokontrolleri balstītas ierīces normālai darbībai.
Protams, lētiem atmiņas karšu moduļiem ir arī trūkumi. Piemēram, lētākie un visizplatītākie modeļi atbalsta tikai kartes līdz 4 GB, un gandrīz visi moduļi ļauj SD kartē saglabāt failus līdz diviem gigabaitiem - tas ir FAT failu sistēmas ierobežojums, ko izmanto lielākajā daļā modeļu.
Vēl viens atmiņas karšu trūkums ir salīdzinoši ilgs ierakstīšanas laiks, taču ir veidi, kā ar to strādāt, ļaujot palielināt tās ātrumu. Šim nolūkam tiek izmantots kešatmiņas mehānisms, kad dati vispirms tiek uzkrāti RAM un pēc tam vienlaikus tiek izmesti atmiņas kartē.
Arduino dēļi darbam ar SD
Lai strādātu ar SD karti, ir vairākas dažādas plates:
- Arduino Ethernet – šī plate ir aprīkota ar īpašu moduli datu izvadīšanai. CS izvadei tiek izmantota tapa 4. Pareizai darbībai ir jāizmanto komanda SD.begin(4).
- Adafruit Micro-SD ir izstrādes plate, kas tiek izmantota, strādājot ar Micro-SD kartēm.
- Sparkfun SD - uzstādīts virs Arduino, CS izvadei izmanto 8. tapu. Plātnes jaunajai versijai ir 3,3 V pieslēgums un iebūvēts sešu bitu invertors.
SD un microSD savienošana ar Arduino
Ir divu veidu kartes – microSD un SD. Tie ir identiski savienojuma, struktūras un programmas ziņā, taču atšķiras tikai pēc izmēra. Pirms lietošanas ieteicams formatēt SD karti. Parasti jaunas kartes jau ir formatētas un gatavas lietošanai, taču, ja izmantojat vecu karti, labāk to formatēt Arduino failu sistēmā. Lai veiktu procedūru, datorā ir jāinstalē SD bibliotēka, vēlams FAT16. Lai formatētu operētājsistēmā Windows, jums jānoklikšķina uz kartes ikonas un noklikšķiniet uz "Formatēt".
Lai savienotu karti, tiek izmantoti 6 kontakti, mijiedarbība tiek veikta caur SPI interfeisu. Tas izskatās kā sešu kontaktu savienotājs uz tāfeles. Lai pievienotu karti, nepieciešams pats kontrolieris, kartes modulis un 6 vadi. Papildus SPI ir arī SDIO režīms, taču to ir grūti ieviest un tas ir slikti saderīgs ar Arduino. SPI ir viegli konfigurēts darbam ar visiem mikrokontrolleriem, tāpēc ieteicams to izmantot.
Digitālās tapas ir savienotas šādi: Arduino Nano vai Uno platei MOSI tapa ir savienota ar D11, MISO pie D12, SCK uz D13, CS uz 4, VCC pie +5 V, .GND uz GND. Plāksnei ir savienotāji savienošanai ar 3,3 un 5 voltiem. Pašai kartei barošanas avots ir 3,3 volti, tāpēc vienkāršāk ir izmantot mikrokontrolleri ar tādu pašu barošanas avotu, pretējā gadījumā nepieciešami sprieguma līmeņa pārveidotāji. Uz visizplatītākajiem Arduino dēļiem ir šāda izvade.
Pievienojot SD karti, jāņem vērā SPI tapu atbilstība dažāda veida Arduino plāksnēm:
Arduino bibliotēka darbam ar SD un microSD
Lai ērtāk strādātu ar ārējiem datu diskdziņiem, Arduino IDE ir pieejamas gatavas bibliotēkas. Vairumā gadījumu jums nekas nav jālejupielādē vai jāinstalē.
Lai skicē iekļautu bibliotēku, izmantojiet iekļaušanas paziņojumu:
#iekļauts
SPI bibliotēka ir nepieciešama, lai pareizi darbotos ar SPI savienotajām ierīcēm.
Bibliotēkas funkcijas ir nepieciešamas datu lasīšanai un ierakstīšanai kartē. Bibliotēka var atbalstīt SD un SDHC kartes.
Vārdi ir rakstīti 8.3 formātā, tas ir, 8 rakstzīmes vārdam, 3 rakstzīmes paplašinājumam. Ceļš uz failu tiek rakstīts, izmantojot slīpsvītras "/".
Iegultās SD bibliotēkas piemēri
Arduino IDE ir iebūvēti piemēri, lai ātri apgūtu bibliotēkas funkcijas:
- Kartes informācija ir SD kartē saglabātās informācijas izvilkums. Ar tās palīdzību var noskaidrot, kurā failu sistēmā ir formatēta karte, cik brīvas vietas, kādi dati tiek ierakstīti.
- Yun Datalogger - ļauj ierakstīt žurnāla datus no trim sensoriem kartē.
- Datalogger - reģistrē un saglabā no sensora saņemtos datus kartē.
- Dump File - nolasīt datus no kartes, pārsūtīt tos uz seriālo portu.
- Faili - izveido un dzēš datus. Ir funkcija file.write(), kas rakstītos datus ievieto buferī. Informācijas pārvietošana uz karti notiek, izsaucot flush() vai close() funkcijas, tāpēc ir svarīgi to aizvērt pēc katras faila atvēršanas, pretējā gadījumā dati tiks zaudēti.
- Read Write - raksta un nolasa failus no kartes.
SD bibliotēkas funkcijas
Arduino SD bibliotēkā ir dažādas funkcijas, kuras var izmantot, lai manipulētu ar datiem. SD klases funkcijas:
- begin() - funkcija inicializē bibliotēku, piešķir signālam kontaktu.
- pastāv() - ir paredzēts, lai pārbaudītu, vai kartē ir nepieciešamā informācija.
- mkdir() - ļauj izveidot vajadzīgo mapi atmiņas kartē.
- rmdir() - izmantojot šo funkciju, varat izdzēst mapi. Ir svarīgi, lai dzēšamā mape būtu tukša.
- open() - ļauj atvērt failu, kas nepieciešams rakstīt vai lasīt. Ja vajadzīgā faila nav kartē, tas tiks izveidots.
- Remove () - noņem jebkuru failu.
Reaģējot uz visām šīm funkcijām, vienai no vērtībām jāizpildās - sekmīgas operācijas pabeigšanas gadījumā un nepatiesai kļūmes gadījumā.
Izveidojiet, rediģējiet un dzēsiet failus.
Lai strādātu ar failiem arduino, ir klase Fails. Tas ietver funkcijas, kas paredzētas informācijas rakstīšanai un lasīšanai no kartes:
- available() — pārbauda, vai failā ir lasīšanai pieejami baiti. Atbilde ir lasīšanai pieejamās vietas apjoms.
- close() - aizver failu, pirms tam pārbauda, vai dati ir saglabāti kartē.
- flush() - funkcija ļauj pārliecināties, ka dati ir ierakstīti kartē.
- name() - atgriež rādītāju uz nosaukumu.
- peek() - nolasa datu baitus, vienlaikus nepārvietojot rādītāju uz nākamo rakstzīmi.
- pozīcija() - atrod rādītāja pašreizējo atrašanās vietu failā.
- print() - izvada datus atsevišķā failā.
- println() - izdrukā datus failā līdz vietai, kur parādās karietes atgriešana un tukša rinda.
- seek() - maina pašreizējās pozīcijas pozīciju failā.
- izmērs() - parāda informāciju par datu lielumu.
- lasīt() - nolasa informāciju.
- write() - raksta failā.
- isDirectory() - izmantojot šo metodi, tā pārbauda, vai fails ir direktorijs, tas ir, direktorijs vai mape.
- openNextFile() - parāda nākamā faila nosaukumu.
- rewindDirectory() - atgriežas pie pirmā faila direktorijā.
Lai dēlis darbotos pareizi, jums jāpārliecinās, vai SS izeja ir konfigurēta.
Piemēra skice darbam ar Arduino SD bibliotēku
Zemāk ir skice, kurā parādīts piemērs darbam ar atmiņas kartes moduli.
/* Datu reģistrētājs, izmantojot SD kartes Piemērs datu saglabāšanai no analogajiem portiem SD kartē. Dati tiks saglabāti failā kā rindu kopa ar lauku atdalītāju simbola "," formā ** CLK - tapa 13 ** CS - tapa 4 */ #include
Faila izveide un nosaukuma izvēle arduino SD kartei
Faila izveide ir viens no visizplatītākajiem uzdevumiem, strādājot ar SD kartēm programmā Arduino. Kā mēs redzējām iepriekšējā skicē, lai izveidotu failu, vienkārši atveriet to. Ja vēlamies pārbaudīt, vai šāds fails eksistē, varam izmantot funkciju exists():
- SD.exists("datalog.csv");
Funkcija atgriež TRUE, ja fails pastāv.
Populāra prakse, veidojot datu reģistrētāju projektus, ir lielu failu sadalīšana mazākos, kurus ērtāk atjaunināt un atvērt datorā. Piemēram, viena ļoti liela datalog.csv faila vietā SD kartē var būt vairāki mazi, beigās pievienojot ciparu: datalog01.csv, datalog02.csv utt.
Šeit ir sniegts skices piemērs, kas palīdzēs paveikt darbu:
char faila nosaukums = "datalog00.csv"; // Sākotnējais nosaukums (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; // Дальше продолжать смысла нет } }
Secinājums
Kā redzējām, SD atmiņas kartes pievienošana Arduino un tās izmantošana projektā nav īpaši sarežģīta. Šim nolūkam Arduino IDE ir gatavas bibliotēkas un dažādas moduļu iespējas. Atmiņas karti var iegādāties jebkurā elektronikas veikalā, tās ir lētas, un tajā pašā laikā tās var ievērojami paplašināt Arduino plates potenciālu. Izmantojot atmiņas kartes, var savākt un saglabāt lielu datu apjomu vēlākai analīzei. Ar mūsu raksta palīdzību mēs varēsim apveltīt savus pētniecības projektus ar atmiņu, izveidot balss paziņojumu sistēmas viedajai mājai, izveidot vienkāršu wav atskaņotāju un daudz ko citu.
