Karty SD jsou založeny na starším formátu multimediálních karet (MMC), ale většina je fyzicky o něco silnější než karty MMC. Mohou se také pochlubit vyšší rychlostí přenosu dat. Funkce DRM jsou dostupné, ale málo používané. SD karty obecně měří 32 mm × 24 mm × 2,1 mm, ale mohou být tenké až 1,4 mm, stejně jako karty MMC.

K dispozici jsou různé stupně rychlosti. Jsou označovány stejnou notací nx jako disky CD-ROM; násobek 150 kB/s. Zařízení se sloty SD mohou používat tenčí MMC karty, ale standardní SD karty se do tenčích slotů MMC nevejdou. MiniSD a MicroSD karty lze použít přímo v SD slotech s adaptérem. Existují čtečky, které umožňují přístup ke kartám SD prostřednictvím mnoha portů připojení, jako je USB, FireWire.

Kolík	Režim SD			Režim SPI
	název	Typ	Popis	název	Typ	Popis
1	CD/DAT3	I/O/PP	Detekce karty / datová linka konektoru 3	C.S.	já	Výběr čipu v nízkém stavu
2	CMD	PP	Příkazový řádek/řádek odezvy	D.I.	já	Vstup dat
3	Vss1	S	GND	VSS	S	GND
4	Vdd	S	Zdroj napájení	VDD	S	Zdroj napájení
5	CLK	já	Hodiny	SCLK	já	Hodiny
6	Vss2	S	GND	VSS2	S	GND
7	DAT0	I/O/PP	Konektorová datová linka 0	DĚLAT	O/PP	Výstup dat
8	DAT1	I/O/PP	Konektorová datová linka 1	RSV
9	DAT2	I/O/PP	Konektorová datová linka 2	RSV

Rozhraní SD karet je kompatibilní se standardními operacemi s kartami MMC. Všechny paměti SD a SDIO karty musí podporovat starší režim SPI/MMC, který podporuje mírně pomalejší čtyřvodičové sériové rozhraní (takty, sériový vstup, sériový výstup, výběr čipu), které je kompatibilní s porty SPI na mnoha mikrokontrolérech. Mnoho digitálních fotoaparátů, digitálních audio přehrávačů a dalších přenosných zařízení pravděpodobně používá výhradně režim MMC. Režim MMC neposkytuje přístup k funkcím proprietárního šifrování karet SD a bezplatná dokumentace SD tyto funkce nepopisuje. Protože šifrování SD existuje především pro producenty médií, není příliš užitečné pro spotřebitele, kteří obvykle používají karty SD k uchovávání nechráněných dat.

SD podporuje tři režimy přenosu: režim SPI (oddělený sériový vstup a sériový výstup), jednobitový režim SD (samostatné příkazové a datové kanály a proprietární přenosový formát) a čtyřbitový režim SD (používá další piny a některé další přeřazené piny) pro podporu čtyřbitových paralelních přenosů. Nízkorychlostní karty podporují přenosovou rychlost 0 až 400 kbit/s a přenosové režimy SPI a jednobitové SD. Vysokorychlostní karty podporují přenosovou rychlost 0 až 100 Mbit/s ve čtyřbitovém režimu a 0 až 25 Mbit/s v režimech SPI a jednobitových SD.

Funkce zabezpečení karet SD zahrnují:

• Mechanismus ochrany autorských práv se standardem SDMI (Secure Digital Music Initiative)
• Integrovaná ochrana souborů a systém šifrování CPRM (CPRM je ochrana obsahu pro nahrávatelná média)

Použití zařízení na bázi mikrokontroléru externí paměť. Pokud potřebujete ukládat jednotky megabajtů, pak jsou vhodné sériové flash paměťové čipy. Pro velké objemy (desítky až stovky megabajtů) se však obvykle používá nějaký druh paměťové karty. Momentálně jsou nejrozšířenější karty SD a microSD, o kterých bych rád pohovořil v sérii materiálů. V tomto článku budeme hovořit o připojení SD karet k mikrokontroléru a v následujícím zjistíme, jak na ně číst nebo zapisovat data.

Pinout karet SD a microSD

SD karty mohou pracovat ve dvou režimech – SD a SPI. Účel pinů karty a schéma zapojení závisí na použitém režimu. 8bitové mikrokontroléry AVR nemají hardwarovou podporu režimu SD, takže karty s nimi se obvykle používají v režimu SPI. 32bitové mikrokontroléry založené na jádru ARM, například AT91SAM3, mají rozhraní pro práci s kartami v režimu SD, takže tam můžete použít libovolný provozní režim.

Přiřazení kontaktů na SD kartě v režimu SD

Přiřazení kontaktů SD karty v režimu SPI

Přiřazení kontaktů microSD karty v režimu SD

Přiřazení kontaktů microSD karty v režimu SPI

Připojení SD a microSD karet k mikrokontroléru v režimu SPI

Napájecí napětí SD karet je 2,7 - 3,3 V. Pokud je použitý mikrokontrolér napájen stejným napětím, pak lze SD připojit k mikrokontroléru přímo. Rasově správné schéma, sestavené studiem specifikací na SD kartách a schémat různých vývojových desek, je znázorněno na obrázku níže. Podle tohoto schématu jsou karty připojeny k vývojové desky společnosti Olimex a Atmel.

Diagram ukazuje kolíky karty SD, nikoli konektor.

L1 - ferit nebo tlumivka, dimenzovaný na proud >100 mA. Někdo si ho nainstaluje, někdo se obejde bez něj. Ale co byste opravdu neměli zanedbávat, je polární kondenzátor C2. Protože při připojení karty dojde k proudovému rázu, napájecí napětí „klesne“ a mikrokontrolér lze resetovat.

Ohledně pull-up odporů panují určité nejasnosti. Protože SD karty vyrábí několik výrobců, existuje pro ně několik specifikací. Některé dokumenty jasně udávají potřebu pull-up rezistorů (i pro nepoužívané linky - 8, 9), zatímco jiné dokumenty tento návod neobsahují (nebo jsem je nenašel).

Zjednodušená verze obvodu (bez pull-up rezistorů) je znázorněna na obrázku níže. Tento obvod je praxí vyzkoušený a používá se v deskách od Microelectronica. Používá se také v mnoha amatérských projektech, které lze nalézt na internetu.

Zde jsou signálové linky SD karty drženy vysoko mikrokontrolérem a nepoužívané linky (8, 9) nejsou nikde připojeny. Teoreticky by měly být vytaženy dovnitř SD karty. Dále budu stavět na tomto schématu.

Pokud je mikrokontrolér napájen jiným napětím, než je napájecí napětí SD karty, například 5 V, pak je potřeba logické úrovně koordinovat. Níže uvedený diagram ukazuje příklad přizpůsobení úrovní karty a mikrokontroléru pomocí napěťových děličů. Princip přizpůsobení úrovní je jednoduchý – z 5 voltů potřebujete získat 3,0 – 3,2 V.

Linka MISO - DO neobsahuje dělič napětí, protože data na něm jsou přenášena z SD karty do mikrokontroléru, ale pro ochranu proti hlupákům tam můžete přidat podobný dělič napětí, nebude to mít vliv na funkci okruhu.

Pokud použijete vyrovnávací čip, jako je CD4050 nebo 74AHC125, aby odpovídal úrovním, lze se těmto nevýhodám vyhnout. Níže je obvod, kde se přizpůsobení úrovně provádí pomocí IC 4050 Tento IC má 6 neinvertujících vyrovnávacích pamětí. Nepoužité tlumiče čipů jsou „tlumené“.

Připojování microSD karet je podobné, jen jejich číslování pinů je mírně odlišné. Dám jen jeden diagram.

Ve schématech jsem se podíval na připojení SD karet k mikrokontroléru přímo - bez konektorů. V praxi se bez nich samozřejmě neobejdete. Existuje několik typů konektorů a mírně se od sebe liší. Piny konektoru zpravidla opakují piny SD karty a obsahují také několik dalších - dva piny pro detekci karty ve slotu a dva piny pro určení blokování zápisu. Tyto piny nejsou nijak elektricky spojeny s SD kartou a není třeba je zapojovat. Pokud jsou však potřeba, lze je připojit jako běžné dotykové tlačítko – jeden pin k zemi, druhý přes odpor k napájecímu kladnému pólu. Nebo místo externího odporu použijte pull-up rezistor mikrokontroléru.

Připojení karet SD a microSD k mikrokontroléru v režimu SD

Pro doplnění obrázku uvedu schéma připojení SD karty v nativním režimu. Umožňuje výměnu dat vyšší rychlostí než režim SPI. Ne všechny mikrokontroléry však disponují hardwarovým rozhraním pro práci s kartou v režimu SD. Mají to například mikrokontroléry ARM SAM3/SAM4 od Atmelu.

Datovou sběrnici DAT lze použít v 1bitovém nebo 4bitovém režimu.

Pokračování příště...

Dobrý den všem! Dnes budeme mluvit o připojení paměťové SD karty k mikrokontroléru STM32.

Zdálo by se, že řadiče STM32F10x mají dostatek paměti, proč by jich bylo více, ale tento dojem klame) Například potřebujeme zobrazit několik různé obrázky– formát 320*240 – tedy 76800 pixelů, z nichž každý odpovídá až 2 bytům. Získáme tedy asi 150 kB na obrázek. A to je podle standardů mikrokontroléru hodně a není pravda, že do jeho paměti Flash lze nacpat dva různé obrázky. Nebo potřebujeme ukládat velké množství informací, dat například z nějakého senzoru. Navíc, aby tato data byla dostupná i po vypnutí napájení. Zde se hodí externí paměť. A skvělé řešení by bylo SD paměťová karta nebo MMC. Mimochodem, v tomto článku budeme provádět experimenty micro SD kartu.

Nejprve pár slov o samotné paměťové kartě, přesněji řečeno o jejím pinoutu. Celé to vypadá takto:

Tak co tu máme? No, hned je jasné, že má osm kolíků. Přiřazení pinů je následující (zleva doprava):

Sloupec SPI Mode nám naznačuje, že interaguje s mikrokontrolérem pomocí rozhraní SPI. ALE! Půjdeme jinou cestou 😉 Jde o to, že STM32 mají na desce hotový periferní modul pro práci s paměťovými kartami a jmenuje se SDIO.

Obecně platí, že interakce s paměťovými kartami zahrnuje odesílání určitých příkazů. Některé příkazy vyžadují argument, některé ne. Příkazy najdete v oficiální dokumentaci ke konkrétní kartě. Vestavěný modul SDIO tedy umožňuje výrazně zjednodušit proces přenosu příkazů a vlastně i proces práce s externími paměťovými kartami. Zde je například registr SDIO_CMD– tam jednoduše opíšeme kód příkazu, který chceme přenést na kartu. Nebo zde je stavový rejstřík SDIO_STA– pro každé kýchnutí je až 24 vlajek, tedy pro velké množství událostí.

Mimochodem, STM potěší i dobrou dokumentací k celé této záležitosti. Zde např. Detailní popis inicializace pro paměťovou kartu SD (u ostatních typů karet je vše popsáno podobně):

Ve skutečnosti je čas přejít k praktickému příkladu. Pojďme se ponořit do standardní periferní knihovny.

V souboru stm32f10x_sdio.h Tradičně najdeme struktury pro všemožná nastavení - tedy pro volbu zdroje hodinového signálu, frekvence SDIO řadiče a nastavení počtu přenesených bytů. Všechno je tam tak velkoryse okomentováno, že se mi to ani nechce zvlášť opakovat)) Jen se podívejte:

typedef struct (uint32_t SDIO_ClockEdge; /* Určuje hodinový přechod, na kterém se provádí zachycení bitu. Tento parametr může mít hodnotu @ref SDIO_Clock_Edge */ uint32_t SDIO_ClockBypass; /* Určuje, zda je povoleno nebo zakázáno přemostění rozdělovače hodin SDIO. Tento parametr může mít hodnotu @ref SDIO_Clock_Bypass */ uint32_t SDIO_ClockPowerSave; /* Určuje, zda je výstup hodin SDIO povolen nebo zakázán, když je sběrnice nečinná. Tento parametr může mít hodnotu @ref SDIO_Clock_Power_Save */ uint32_t SDIO_BusWide; /* Určuje šířku sběrnice SDIO. Tento parametr může mít hodnotu @ref SDIO_Bus_Wide */ uint32_t SDIO_HardwareFlowControl; /* Určuje, zda je povoleno nebo zakázáno řízení toku hardwaru SDIO. Tento parametr může mít hodnotu @ref SDIO_Hardware_Flow_Control */ uint8_t SDIO_ClockDiv; /* Určuje taktovací frekvenci řadiče SDIO. Tento parametr může mít hodnotu mezi 0x00 a 0xFF. */) SDIO_InitTypeDef; typedef struct (uint32_t SDIO_Argument; /* Určuje argument příkazu SDIO, který je odeslán na kartu jako součást příkazové zprávy. Pokud příkaz obsahuje argument, musí být před zápisem příkazu do registru příkazů načten do tohoto registru */ uint32_t SDIO_CmdIndex; /* Určuje index příkazu SDIO. Musí být menší než 0x40. */ uint32_t SDIO_Response; /* Určuje typ odpovědi SDIO. Tento parametr může mít hodnotu @ref SDIO_Response_Type */ uint32_t SDIO_Wait; /* Určuje, zda je povolen nebo zakázán požadavek na čekání na přerušení SDIO. Tento parametr může mít hodnotu @ref SDIO_Wait_Interrupt_State */ uint32_t SDIO_CPSM; /* Určuje, zda je povolen nebo zakázán stavový stroj SDIO Command path state machine (CPSM). Tento parametr může mít hodnotu @ref SDIO_CPSM_State */) SDIO_CmdInitTypeDef; typedef struct (uint32_t SDIO_DataTimeOut; /* Určuje časový limit dat v periodách hodin sběrnice karty. */ uint32_t SDIO_DataLength; /* Určuje počet datových bajtů, které mají být přeneseny. */ uint32_t SDIO_DataBlockSize; /* Určuje velikost bloku dat pro přenos bloku. Tento parametr může mít hodnotu @ref SDIO_Data_Block_Size */ uint32_t SDIO_TransferDir; /* Určuje směr přenosu dat, zda je přenos čtení nebo zápis. Tento parametr může mít hodnotu @ref SDIO_Transfer_Direction */ uint32_t SDIO_TransferMode; /* Určuje, zda je přenos dat v režimu streamování nebo blokování. Tento parametr může mít hodnotu @ref SDIO_Transfer_Type */ uint32_t SDIO_DPSM; /* Určuje, zda je povolen nebo zakázán stavový stroj SDIO Data path State Machine (DPSM). Tento parametr může mít hodnotu @ref SDIO_DPSM_State */) SDIO_DataInitTypeDef;

Všimněme si, jak SPL implementuje přenos příkazů na paměťovou kartu. Pro tyto účely byla vyčleněna samostatná struktura. SDIO_CmdInitTypeDef. V terénu SDIO_CmdIndex do pole zadejte kód příkazu SDIO_Argument– argument příkazu, vyplňte také zbývající pole. Nezbývá než tato data nějak nacpat mikrokarta SD 😉 A k tomu si pro nás připravili funkci:

SDIO_SendCommand (SDIO_CmdInitTypeDef *SDIO_CmdInitStruct)

Jako argument mu předáme strukturu, kterou jsme vytvořili. Pro záznam dat existuje funkce - SDIO_WriteData(uint32_t Data). Po zavolání této funkce budou data v registru speciálně navrženém pro tento účel - SDIO_FIFO.

Takto pracujete s modulem SDIO v STM32F10x)

Nyní přejděme konečně ke cvičení. Budu opět pracovat s deskou Mini STM32, protože laskaví Číňané si lámali hlavu s instalací slotu pro paměťovou kartu micro SD na ni. Zde je schéma připojení konektoru karty k mikrokontroléru:

K napsání programu použijeme hotový příklad pro Keil - vezmeme si odtud dva soubory, ve kterých je implementováno něco jako ovladač pro práci s kartami - to jsou soubory sdcard.c A sdcard.h. tvoříme nový projekt, tam přikládáme tyto soubory a kromě toho samozřejmě soubory CMSIS a SPL. Zde je hotový projekt, ve kterém již bylo vše přidáno - zbývá pouze napsat kód pro funkci main()

Soubor sdcard.c implementuje nejrůznější funkce pro práci s paměťovou kartou, teď už je jen zbývá použít 😉 Pojďme napsat kód! Zapišme například 512 bajtů testovacích dat na micro SD a poté je zkusme přečíst:

// Propojte potřebné soubory#include "stm32f10x.h" #include "sdcard.h" /*******************************************************************/ // Pole vstupních a výstupních dat a proměnná pro ukládání dat// o naší kartě uint8_t writeBuffer[ 512 ] ; uint8_t readBuffer[ 512]; SD_CardInfo SDCardInfo; /*******************************************************************/ int main() ( // Testovací data k zápisu for (uint16_t i = 0; i< 512 ; i++ ) { writeBuffer[ i] = i % 256 ; readBuffer[ i] = 0 ; } // Inicializace mapy SD_Init() ; // Získání informací o kartě SD_GetCardInfo(& SDCardInfo) ; // Výběr karty a nastavení provozního režimu SD_SelectDeselect((uint32_t ) (SDCardInfo.RCA<< 16 ) ) ; SD_SetDeviceMode(SD_POLLING_MODE) ; // A nakonec psaní a čtení SD_WriteBlock(0x00, writeBuffer, 512) ; SD_ReadBlock(0x00, readBuffer, 512) ; zatímco (1) ()) /*******************************************************************/

Vezměte prosím na vědomí, že SD karta podporuje záznam v 512 bajtových blocích.

Pokud spustíme program pod debuggerem, uvidíme, že načtená data se shodují se zapsanými =) Experiment tedy můžeme považovat za úspěšný. To je pro dnešek vše, brzy se uvidíme!

Jak víte, paměťové karty SD jsou kompatibilní s rozhraním SPI, takže je lze snadno připojit k mikrokontroléru a komunikovat s nimi. K dispozici jsou také adaptéry pro microSD karty, z takového adaptéru můžeme udělat slot pro microSD kartu pro naše rozložení. Níže uvedené fotografie ukazují vzhled vyrobeného adaptéru pro připojení k prkénku.

Projekt zpočátku používal paměťovou kartu microSD s kapacitou 1 GB. Mikrokontrolér je ATmega8 nebo ATmega32, pracující na frekvenci 8 MHz z interního RC oscilátoru. Kromě toho bylo použito rozhraní RS-232 pro připojení prototypu k osobnímu počítači pro sledování dat. Pro převod logických úrovní rozhraní je použit čip MAX232. Pro napájení obvodu je potřeba stabilizovaný zdroj 3,3 V (čip MAX232 je dimenzován na napájecí napětí 5 V, nicméně, jak ukázala praxe, zůstává funkční na 3,3 V). Připojení paměťové karty pomocí 7vodičového obvodu, podle pinutu (viz obrázek).

Schématické schéma mikrokontroléru ATmega8.

Pull-up rezistory R1, R2 s nominální hodnotou 51 kOhm rozhraní SPI poskytují lepší stabilitu při práci s různými kartami. Zenerovy diody D1, D2 jsou určeny k ochraně paměťové karty během provozu in-circuit programátoru (ISP). Piny čipu MAX232 VCC a GND nejsou na schématech vyznačeny, ale musí být připojeny k odpovídajícím bodům schématu.

Schéma zapojení pro mikrokontrolér ATmega32

Schematický diagram pro mikrokontrolér ATmega32 (přidané hodiny reálného času na čipu DS1307)

Jak jste si všimli, nejnovější verze zařízení je napájena ze zdroje 12 V a deska má dva regulátory napětí 5,0 V (LM7805) a 3,3 V (LM1117-3,3). Pro napájení rozhraní SD karty je použito 3,3 V, zbytek obvodu je napájen ze zdroje 5,0 V Čip hodin reálného času DS1307 je ve standardní konfiguraci a je připojen k I2C rozhraní mikrokontroléru.

Nejprve byl studován „surový“ formát přenosu dat na příkladu operací čtení libovolného datového bloku, čtení a zápisu několika bloků dat, mazání několika bloků, zápis dat do libovolného paměťového bloku SD. Zařízení, sestavené na prkénku, bylo připojeno k počítači přes rozhraní RS-232. Pro zobrazení načtených dat z paměťové karty, jakož i pro zadávání a zápis dat na kartu použijte program HyperTerminal (nebo podobný) v počítači.

Po úspěšné implementaci výměny dat bez specifikace byla paměťová karta naformátována (FAT32) v operačním systému Windows XP, poté bylo na kartu zapsáno několik textových souborů, adresářů a dalších typů souborů (v kořenovém adresáři karty). Poté byly napsány rutiny a funkce pro práci se systémem souborů FAT32 pro čtení souborů, pro získání seznamu souborů na paměťové kartě (pomocí HiperTerminal), pro získání informací o plné a volné paměti.

Pohled na okno programu HiperTerminal s funkcemi pro práci s paměťovou kartou SD:

Uživateli se nabízí přes 10 možností práce s paměťovou kartou (u verze s hodinami).

Možnosti 0-4 Jedná se o nízkoúrovňové funkce. Po použití možností 0 - 3 budete muset před použitím rutin FAT32 kartu přeformátovat.
Možnosti 5-9- viz systém souborů FAT32. V současné době jsou podporovány pouze krátké názvy souborů (8 bajtů - název souboru, 3 bajty - přípona souboru). Pokud jsou zapsány soubory s dlouhými názvy, zobrazí se v terminálovém programu v krátkém formátu. Chcete-li tyto možnosti vyzkoušet, nezapomeňte naformátovat kartu v souborovém systému FAT32 a zapsat si několik adresářů a textových souborů.

Popis možností:

0 - Vymazat bloky- vymazání zvoleného počtu bloků počínaje zadaným.
1 - Zápis jednoho bloku- zápis dat do bloku s konkrétní adresou. Data se zadávají z klávesnice v programu Hiperterminal;
2 - Čtení jednoho bloku- čtení dat z bloku s konkrétní adresou. Načtená data se zobrazí v okně programu terminálu;
3 - Psaní více bloků- záznam několika bloků počínaje určitou adresou;
4 - Čtení více bloků- čtení několika bloků počínaje určitou adresou.

Poznámka. Zde jsou funkce více bloků (možnosti 3 a 4) deaktivovány kvůli omezením paměti na mikrokontroléru ATmega8, protože tyto funkce nejsou potřeba k testování systému souborů FAT32. Chcete-li povolit tyto možnosti, musíte odebrat makro ze souboru SD_routines.h (#define FAT_TESTING_ONLY). A pokud používáte ATmega8, při testování možností 3 a 4 lze smazat knihovnu FAT32, aby se uvolnila paměť mikrokontroléru.

5 - Získejte seznam souborů- zobrazí seznam dostupných adresářů a souborů s velikostí paměti, kterou zabírají (v kořenovém adresáři karty);
6 - Přečtěte si soubor- čtení zadaného souboru a zobrazení obsahu v okně programu terminálu;
7 - Vytvořit soubor- vytvořit/přidat soubor se zadaným názvem;
8 - Smazat soubor- odstranit všechny soubory se zadaným názvem;
9 - Kapacita paměti SD čtení- informace o plné a volné kapacitě paměťové karty (využívá se sektor FSinfo SD karty).

V terminálovém programu je sériový port nakonfigurován na přenosovou rychlost 19200, bez řízení toku a bez kontroly parity.

U verze s hodinami reálného času (DS1307) na mikrokontroléru ATmega32 jsou vlastnosti vytvořených nebo aktualizovaných souborů vázány na datum a čas (datum vytvoření/změny), tyto vlastnosti jsou registrovány v tabulce souborů a lze je kontrolovat pomocí počítače a hodiny mohou být také užitečné při sběru dat. Do nabídky možností v programu terminálu byly přidány tři možnosti.

Lekce 33

Část 1

SPI. SD karta. TLUSTÝ

Dnes budeme pokračovat v našem oblíbeném tématu o rozhraní SPI. S touto sběrnicí propojující řadiče Atmega8a a ATTtiny2313 jsme skončili. A dnes si zkusíme připojit paměťovou kartu k mikrokontroléru přes tuto sběrnici pomocí tohoto rozhraní SD (Secure Digital).

Tuto kartu lze připojit i přes SDIO rozhraní, ale protože takové rozhraní není naším ovladačem hardwarově podporováno, nebudeme se ho v této lekci dotýkat. Zajímá nás typ autobusového spojení SPI, protože již máme dobré nashromážděné znalosti o tomto tématu a také hardwarovou podporu v ovladači, který programujeme.

Přesto se u obou typů podíváme na pinout noh karet

No a jelikož nás zajímá druhý typ, budeme se jím zabývat.

A tady tomu není moc k pochopení. Všechny tyto zkratky známe. Všechny standardní piny rozhraní SPI jsou zde a není zde nic nadbytečného.

Nyní o mapě obecně. Tato karta nám umožňuje ukládat data, její typ paměti je FLASH, která je oproti pamětem typu EEPROM také energeticky nezávislá, to znamená, že po vypnutí napájení data nikam nezmizí, ale zůstanou uložena. Také tato paměť má rozdíly, seznámíme se s nimi během procesu programování. Jedním z hlavních rozdílů je, že stejně jako v paměti EEPROM nemůžeme do této paměti zapsat jeden bajt. Teoreticky samozřejmě můžeme, ale budou se tam psát buď jen jedničky z našeho bajtu, nebo jen nuly, podle typu FLASH - NOR nebo NAND. Tzn., že před zápisem bajtu jej musíme vymazat a vzhledem k organizaci této paměti můžeme mazat pouze po blocích, můžeme tedy zapisovat pouze po blocích. Největší rozdíl oproti EEPROM je ale v ceně. Je mnohonásobně levnější, někdy i řádově levnější za jednu uloženou jednotku informace (za megabajt, za gigabajt). FLASH paměť má proto obvykle vždy mnohem větší množství informací.

Existují 4 typy SD, ale to prostudujeme o něco později.

Pojďme připojit tuto kartu, když jsme v Proteus

Všechno je zde jednoduché. Vlastně ne tak docela. Potřebujete více odporů

Tyto odpory jsou potřebné k zajištění odpovídající úrovně, protože karta je napájena 3,3 volty. Obecně, podle technické dokumentace, od 2,7 do 3,6 voltů.

Také to není uvedeno v proteu, ale ve skutečnosti budeme naši kartu napájet ze samostatného zdroje napájení instalací mikroobvodu, který převádí 5 voltů na 3,3 voltů.

Nebo spíše nebudeme nic instalovat, ale použijeme hotový modul, ve kterém je již vše nainstalováno.

Máme také připojený displej, jako při rozšiřování funkčnosti knihovny displejů.

Takto to vše vypadá v praxi:

Takto vypadá modul s držákem

Takový modul najdete všude, stojí korunu. Modul, který se připojuje přes SDIO, stojí více. Také vidíme, že modul již má nainstalovaný mikroobvod pro snížení napětí na 3,3 voltu. A připojujeme napájení pouze k 5V kontaktu a nepřipojujeme nic k 3.3

Na modulu jsou také nainstalovány všechny děliče úrovní, to znamená, že tento modul je navržen speciálně pro připojení k 5voltovým zařízením.

A vyhrabal jsem na testy flash kartu s 32 megabajty, přesně megabajt a ne gigabajt

Tato flash karta byla dána jako dárek spolu s nějakým fotoaparátem a nejlépe se hodí pro naše testy, alespoň si nebudeme myslet, že ta či ona závada je způsobena příliš velkým množstvím paměti na kartě.

Celý kód byl také převzat z minulé lekce spolu s knihovnou zobrazení, protože funkci, kterou jsme vytvořili v minulé lekci, budeme používat velmi aktivně, ale samozřejmě byl vytvořen nový projekt a podle toho pojmenován MYSD_SPI.

Odstraňme zbytečné řádky, v main() budeme mít pouze toto

inthlavní( prázdnota)

nepodepsanýinti;

Port_ini();

LCD_ini(); //inicializovat displej

Clearlcd(); //vymazat displej

Setpos(0,0);

Str_lcd( "řetězec 1");

Setpos(2,1);

Str_lcd( "řetězec 2");

Setpos(4,2);

Str_lcd( "Řetězec 3");

Setpos(6,3);

Str_lcd( "řetězec 4");

Zpoždění_ms(2000);

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

Zatímco(1)

Protože nebudeme vypisovat text znak po znaku, můžeme použít typ char v proměnné

nepodepsanýchar i;

Nyní ještě jedna nuance.

Abychom mohli pracovat s SD kartou v Proteusu, nestačí nám přidat samotný držák s kartou, musíme v jejích vlastnostech připojit i soubor obrázku flash karty;

Není těžké si ho vytvořit. Jedním ze způsobů je vytvoření pomocí programu WinImage.

Vytvoříme v něm nový soubor pomocí položky nabídky Soubor -> Nový. Vyberte úplně poslední položku v dialogovém okně a klikněte na "OK"

Pro test v Proteus nám stačí velikost 4 megabajty, takže v dalším dialogu změníme pole s počtem sektorů a vybereme také formát FAT12/16, protože specifika práce s 32- bitový souborový systém se mírně liší a také klikneme na „OK“

Obecně samozřejmě můžeme nechat FAT32, jelikož se souborovým systémem zatím nepracujeme, ale v dalších částech lekce budeme pracovat se souborovým systémem a budeme pracovat s 12/16.

Pak ušetříme naše cos tento soubor pomocí položky nabídky Soubor -> Uložit jako. A uložíme do složky, kde máme uložený projekt proteus. Pojmenujme soubor a klikněte na "Uložit"

Také se budeme muset ujistit, že tento soubor není s atributem „pouze pro čtení“, a poté jej budeme moci připojit v Proteus. Budete muset ručně zadat název souboru, protože Proteus vyžaduje nějaký formát a náš soubor prostě nebude viditelný

Nepotřebujeme žádnou cestu, protože soubor je umístěn ve složce projektu. Klikněte na "OK".

Nemusíme inicializovat sběrnici, protože naše SPI bude založené na softwaru, ne všechny flash karty fungují správně s hardwarem, takže nebudeme muset používat žádné registry. Hardware je samozřejmě lepší, ale abyste důkladně pochopili, jak protokol funguje, je potřeba pracovat i se softwarem, tedy škubat nožičkami portů. Obecně se při pohledu na diagram může zdát, že máme vše v hardwaru, protože jsem si vybral přesně tyto nohy, je to proto, že jsem si to tak vybral, takže později možná někdo zkusí pracovat s pneumatikami implementace hardwaru .

Pojďme přidat makro substituce pro porty

#zahrnout"hlavní.h"

#definovatMOSI3

#definovatMISO4

#definovatSCK5

#definovatSS2

Přidejme kód pro inicializaci noh do funkce inicializace portu

prázdnotaport_ini( prázdnota)

PORTD=0x00;

DDRD=0xFF;

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

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

MISO pin ponecháme na vstupu, protože standardně jsou všechny bity v registru nulové a jednoduše se ho nedotkneme. Okamžitě také zapneme vysokou úroveň v MOSI a SS a přitáhneme odpor k MISO.

Napišme funkci pro přenos bajtu po sběrnici SPI

prázdnotaSPI_SendByte( nepodepsanýcharbyte)

{

}

Přidejme proměnnou pro smyčku a samotnou smyčku

prázdnotaSPI_SendByte( nepodepsanýcharbyte)

nepodepsanýchari;

pro( i=0; i<8; i++) //pohyb po bitech bajtu

{

}

Myslím, že je jasné, proč počítáme do 8, protože vysíláme přesně 8 bitů.

No, začněme je přenášet postupně.

Nejprve zkontrolujeme bit úplně vlevo, izolujeme jej od celého bajtu maskováním, a pokud je roven 1, nastavíme jej na 1 na sběrnici MOSI, a pokud je 0, nedotkneme se sběrnice

pro( i=0; i<8; i++) //pohyb po bitech bajtu