SD kaart

Vajalikud teadmised: [HW] Kontrollermoodul, [HW] Kasutajaliidese moodul,
[LIB] Sisend-väljundviigud, [LIB] Graafiline LCD

Secure Digital (SD) on mälukaardi formaat, mille töötas välja SD Card Association (SDA) eesmärgiga kasutada seda kaasaskantavates seadmetes. Kaartiga suhtlemiseks saab kasutada kaarti enda SD nimelist liidest või SPI siini. Viimane on hea võimalus kasutada SD kaarti lihtsamates süsteemides. SD kaardi tööpinge on 3,3 V.

SD kaart on iseenesest suur hulk mälubitte, mida saab küll muuta, aga muud seadmed ei oska salvestatud andmetega seljuhul midagi peale hakata. Probleemi lahendamiseks kasutatakse failisüsteemi, mis annab võimaluse töötada kogu kaardi mälumaatriksi asemel failidega. Failisüsteemi üks tähtsamaid ülesandeid on organiseerida loogilisi faile füüsilisel salvestusseadmel. Salvestusseadmel olev ruum on jaotatud sektoriteks, mille suurus on enamasti 512 baiti. Kuna failisüsteemil on otstarbekas töötada suuremate üksustega, grupeeritakse sektoreid klastriteks. Klaster on mingi täisarvuline hulk järjestikuliselt asuvaid sektoreid. Suurema klastri kasutamisel väheneb suuremate failide puhul fragmentatsioon, kuid väiksemate failide puhul suureneb raisatud ruum, kuna osa klastreid jääb ainult osaliselt täidetuks.

Portatiivsetel mäluseadmetel ja mälukaartidel on laialt levinud FAT (File Allocation Table) failisüsteem, mida toetavad kõik enamlevinud operatsioonisüsteemid. FAT failisüsteemi failipaigutustabel sisaldab iga kettal oleva faili algusklastri kannet, mis omakorda sisaldab viita järgmisele failiga seotud klastrile ja nii edasi, kuni faililõpu klastrini. FAT-i korral on klastrid adresseeritud n-bitiste kannetega aadressiruumi tabelisse, kus n on sõltuvalt FAT-i versioonist 12 (FAT12), 16 (FAT16) või 32 bitti (FAT32). Seega vanemate FAT versioonide korral muutusid suurte kettamahtude korral klastrid mahult suureks ja seega kettamahu kasutamine ebaefektiivseks.

SD mälukaardid on saadaval kolmes füüsilises korpuses, millest kõige suurem on nn tavaline SD kaart, väiksem miniSD kaart ja kõige väiksem microSD kaart. microSD kaart on levinud mobiiltelefonides ja tahvelarvutites. Samuti on see formaat kasutusel ka Robootika Kodulabori Kontrollermoodulil. Lisaks välisele korpusele jagatakse SD kaardid veel põlvkondadeks:

• I põlvkond: SD - mahuga kuni 2 GB
• II põlvkond: SDHC - mahuga kuni 32 GB
• III põlvkond: SDXC - mahuga kuni 2 TB

SD kaardid on erineva kiirusega, mille määratlemiseks kasutatakse klasside süsteemi (inglise keeles Speed Class Rating, lühend SCR) Levinumad kiiruse klassid on:

• 2 MB/s
• 4 MB/s
• 6 MB/s
• 10 MB/s

Kodulabori Kontrollermoodulil on pesa microSD mälukaardi sisestamiseks. Mälukaart on ühendatud SPI siinile, Kodulabor II Kontrollermoodulil samale siinile Ethernet kontrolleriga. Kodulabori teeki on integreeritud FatFs failisüsteemi moodul millega on võimalik lähemalt tutvuda aadressil: http://elm-chan.org/fsw/ff/00index_e.html. FatFs failisüsteemi moodulis on SD kaardiga suhtlemiseks kaks kihti. Esimene ketta kiht paikneb failides diskio.h ja mmc.c. See on otseselt seotud kettaga suhtlemise ja selle algväärtustamisega. Lisaks paiknevad seal madala taseme kettale kirjutamise ja lugemisega seotud funktsioonid. Lõppkasutaja jaoks on kõige tähtsam funktsioon disk_initialize, mis seadistab valitud kaardi töökorda.

Failisüsteemi tööks on vaja välja kutsuda funktsioon disk_timerproc sagedusega 100 Hz. Selleks on seadistatud taimeri katkestus. Kodulabori Kontrollermoodulil puudub reaalaja kell, mis tähendab, et failidega seotud kellaajad on konstantsed.

Teine failisüsteemi kiht paikneb failides ff.c ja ff.h. See kiht suhtleb esimese kihiga madala taseme funktsioonide kaudu ja võimaldab teha failidega seotud toiminguid. Failisüsteemi saab ühendada alles peale ketta töökorda seadmist, milleks on funktsioon f_mount. Funktsioonile tuleb ette anda failisüsteemi objekt ja see tagastab tulemuse koodi.

Peale ketta ja failisüsteemi töökorda seadmist saab alustada tööd konkreetsete failidega. Faili avamiseks on funktsioon f_open, millele saab ette anda, millises režiimis see avatakse. Valikuid on mitmeid, näiteks FA_WRITE tähendab, et fail avatakse kirjutusrežiimis. Seejärel saab faili kirjutada funktsiooniga f_write, või hoopis lugeda funktsiooniga f_read. Kui failiga on töö lõppenud, siis tuleb see sulgeda, kasutades funktsiooni f_close. Toetatud ja testitud on FAT12, FAT16 ja FAT32 failisüsteemid.

Järgmine näide demonstreerib tekstifaili lugemist ja kirjutamist. Nupule S1 vajutades initsialiseeritakse kaart ja failisüsteem. Nupu S3 vajutamisel luuakse kettale kaust, kuhu omakorda luuakse fail. Faili kirjutatakse ka sisu. Nupp S2 kuvab tekitatud faili sisu ekraanile.

// Kodulabori SD kaardi kasutamise näidisprogramm
#include <stdio.h>
#include <homelab/module/ff.h>
#include <homelab/module/diskio.h>
#include <homelab/delay.h>
#include <homelab/pin.h>
#include <homelab/module/lcd_gfx.h>
 
// Põhiprogramm
int main (void)
{
	// Ketta vea lipp
	int f_err_flag = -1;
	// Failisüsteemi vea lipp
	int d_err_flag = -1; 
	char f_err_buf[16];
	char d_err_buf[16];
 
	int variableName = 0;
 
	static FATFS FATFS_Obj;
        FIL fil_obj;
 
	char read_buf[20];
 
	unsigned char new_value1, old_value1 = 0;
	unsigned char new_value2, old_value2 = 0;
	unsigned char new_value3, old_value3 = 0;
 
	// LED-ide töökorda seadmine ja välja lülitamine
	pin_setup_output(led_red); pin_set(led_red);
	pin_setup_output(led_yellow); pin_set(led_yellow);
	pin_setup_output(led_green); pin_set(led_green);
 
	// LCD ekraani seadistamine ja teksti kuvamine
	lcd_gfx_init();
	lcd_gfx_goto_char_xy(3, 2);
	lcd_gfx_write_string("SD Card");
 
	// Lõputu tsükkel
	while (1) 
	{
		// Nuppude väärtuste lugemine
		new_value1 = pin_get_debounced_value(button1);
		new_value2 = pin_get_debounced_value(button2);
		new_value3 = pin_get_debounced_value(button3);
 
		// Nupp S1 alla vajutatud. Registreeritakse ainult üks vajutus.
		if((!new_value1) && (old_value1))
		{
			// SD kaardi initsialiseerimine
			// Ebaõnnestumise korral seatakse vealipp.
			d_err_flag = disk_initialize(0);
			sw_delay_ms(2);
 
			// Failisüsteemi initsialiseerimine
			// Ebaõnnestumise korral seatakse vealipp.
			f_err_flag = f_mount(0, &FATFS_Obj);
			sw_delay_ms(2);
		} 
 
		// Nupp S2 vajutatud. Registreeritakse ainult üks vajutus
		if((!new_value2) && (old_value2))
		{
			// Faili "fail.txt" avamine lugemisrežiimis
			f_open(&fil_obj, "/Homelab/fail.txt", FA_READ);
 
			// Failist esimese 14 tähemärgi lugemine
			f_gets (read_buf,14, &fil_obj);
			f_close(&fil_obj);
 
			// Faili esimese 14 tähemärgi ekraanile kirjutamine
			lcd_gfx_goto_char_xy(0, 0);
			lcd_gfx_write_string(read_buf);
 
		}
 
		// Nupp S3 vajutatud. Registreeritakse ainult üks vajutus
		if((!new_value3) && (old_value3))
		{
			// Suvaline muutuja, mis salvestatakse faili
			variableName = 4;			
 
			// Kettale luuakse kaust "Homelab"
			f_mkdir("Homelab");	
 
			// Loodud kausta tekitatakse tekstifail "fail.txt"
			f_open(&fil_obj, "/Homelab/fail.txt", FA_CREATE_NEW);
 
			// Fail avatakse kirjutusrežiimis
			f_open(&fil_obj, "/Homelab/fail.txt", FA_WRITE);		
 
			// Faili kirjutamine
			f_printf(&fil_obj, "Variable: %d", variableName);
 
 			// Faili sulgemine
			f_close(&fil_obj);
		}
 
		// Eelmise nupu väärtuse meelde jätmine
		old_value1 = new_value1;
		old_value2 = new_value2;
		old_value3 = new_value3;		
 
		// Kui SD-kaart on initsialiseeritud ja töökorras, siis põleb 
		// roheline LED ja vastupidisel juhul punane LED
		if((f_err_flag == 0) && (d_err_flag == 0))
		{
			pin_clear(led_green);
			pin_set(led_red);			
		}
		else
		{			
			pin_set(led_green);
			pin_clear(led_red);
		}
 
		// Ekraanile kuvatakse vealippude olekud. Need on järgnevad:
		// -1 initsialiseerimata
		//  0 viga ei ole
		//  1 (või suurem) viga		
		sprintf(f_err_buf, "Error_f: %02d", f_err_flag );
		sprintf(d_err_buf, "Error_d: %02d", d_err_flag );
 
		lcd_gfx_goto_char_xy(0, 4);
		lcd_gfx_write_string(f_err_buf);
		lcd_gfx_goto_char_xy(0, 5);
		lcd_gfx_write_string(d_err_buf);
 
		sw_delay_ms(2);		
	}
}