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í. Tady se nám to bude hodit 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í karty Paměť. 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 se jedná o 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 zadejte do pole kód příkazu SDIO_Argument– argument příkazu, vyplňte také zbývající pole. Nezbývá než tato data nějak nacpat mikro karta 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 znovu pracovat s Mini deska STM32, protože dobří Číňané si lámali hlavu instalací slotu pro paměťovou kartu micro SD na něj. Zde je schéma připojení konektoru karty k mikrokontroléru:

K napsání programu, který použijeme hotový příklad pro Keil - vezměme 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!

Andreas říká:

Sestavení adaptéru Memory Stick vlastníma rukama není obtížné, pokud znáte účel funkčních kolíků konkrétní paměťové karty. Obvykle se nazývá pinout paměťové karty nebo například mikroobvod, čip atd. Obecně je technologie jednoduchá. Rozložení paměťové karty MMC (MultiMedia Card) je vyříznuto z PCB. Na prkénku je vyříznuto 7 stop (MMC má 7 kolíků). Poté, v souladu s pinoutem znázorněným na obrázku níže, jsou stopy připájeny ke kolíkům paměťové karty SD (má 9 kolíků, z nichž 2 nejsou použity), microSD (má 8 kolíků, z nichž 2 také nejsou používá, ale nezapomeňte, že paměť microSD karty nemá výstup Vcc) nebo microM2 (vývod microM2 v souvisejícím tématu Adaptér Memory Stick Micro M2). To je vše. Adaptér Memory Stick je připraven.

P.S. Skladem máme paměťové karty MMC 1 a 2 GB. Cena je 285 a 360 rublů. Doprava je zahrnuta v uvedené ceně.

Můžete také levně zakoupit následující velikosti paměťových karet:
- Memory Stick a Memory Stick M2;
- Secure Digital (SD);
- Mini SD;
- Micro SD (TF);
- Compact Flash;
-XD;
- USB flash disky různých provedení a kapacit.
Například tyto:

slava říká:

Mimochodem, nemám v těchto spisech příliš jasno. Na této stránce nemůžete získat skladby z MicroCD do MMC, budu vám velmi vděčný.

Andreas říká:

Takto bude vypadat adaptér microSD na MMC:

slava říká:

Jak je patrné z obrázku, po vyslání příkazového rámce je nutné pokračovat ve čtení bajtů (Ncr) z microSD až do obdržení odpovědi (R1), přičemž úroveň CS musí být aktivní „0“.

V závislosti na indexu příkazů může být odpověď nejen R1(viz sada základních příkazů) na odpověď CMD58 R3(R1 a koncová 32bitová hodnota OCR) a některé příkazy vyžadují více času NCR a budou reagovat R1b. Toto je odpověď R1, následovaná příznakem obsazenosti (signál na lince „DO“ je kartou udržován na nízké úrovni, zatímco interní proces pokračuje). Hostitelský řadič musí čekat na dokončení procesu, dokud se "DO" nezvýší (tj. počkat na 0xFF). A také R2 při požadavku na stav registru STATUS.

Odpověď R1 obsahuje 1 byte, její strukturu můžete vidět v tabulce níže. Odpověď R2 se skládá ze dvou bajtů, první bajt je R1 a druhý R2 (viz tabulka struktury R2). A odpověď R3 je respektive 5 bajtů.

Odpověď R1 s hodnotou 0x00 znamená, že příkaz byl úspěšně dokončen, jinak bude nastaven odpovídající příznak.

Struktura odpovědi R1.

Struktura odezvy R2.

Inicializace v režimu SPI.

Po resetu a napájení je karta standardně nastavena do provozního režimu pomocí protokolu MMC (Serial Peripheral Interface), pro přepnutí do režimu SPI je třeba provést následující:

1. Po dosažení 2,2 V počkejte alespoň milisekundu, nastavte DI a CS linky na vysokou úroveň a vydejte asi 80 impulsů na pin CLK. Po tomto postupu bude karta připravena přijmout domácí tým.
2. Odešlete příkaz CMD0 (soft reset). Karta musí reagovat (R1) s nastaveným bitem čekání (0x01).
3. Odešlete příkaz CMD1 (pro zahájení inicializace karty). Počkejte na odpověď 0x00 pro potvrzení dokončení procesu inicializace.

Dovolte mi připomenout, že příkaz CMD0 musí obsahovat správné pole CRC. Nemá smysl počítat, protože v tomto příkazu nejsou žádné argumenty, takže je konstantní a má hodnotu 0x95. Když karta přejde do režimu SPI, funkce CRC bude deaktivována a nebude kontrolována. Možnost CRC lze znovu aktivovat pomocí CMD59.

V důsledku toho bude příkaz CMD0 vypadat takto: 0x40.0x00.0x00.0x00.0x00.0x95.

• index týmu - 0x40.
• argument - 0x00.0x00.0x00.0x00.
• CRC-0x95.

Pokud jde o 80 impulsů, lze je generovat přenosem hodnoty 0xFF přes SPI10x za sebouna vysokých úrovních nastavených na linkách DI a CS.

Po nečinnosti déle než 5 ms přejde paměťová karta do režimu úspory energie a je schopna přijímat pouze příkazy CMD0, CMD1 a CMD58. Proces inicializace (CMD1) je proto nutné opakovat téměř pokaždé při čtení/zápisu datového bloku nebo kontrole stavu karty.

Pro SDC karty pokud je příkaz odmítnutCMD1 se doporučuje použít příkaz ACMD41.

Samotný proces inicializace může trvat poměrně dlouho (v závislosti na velikosti karty) a může dosáhnout stovek milisekund.

Čtení a zápis datového bloku.

Ve výchozím nastavení probíhá v režimu SPI výměna mezi mikrokontrolérem a kartou v blocích po 512 bytech, takže pro zápis byť jednoho bajtu budete muset nejprve přečíst celý blok a změnou bajtu jej přepsat zpět. Velikost bloku lze změnit v registru CSD paměťové karty.

Aby se předešlo chybám při adresování při provádění příkazů pro čtení/zápis, je nutné, aby adresa byla jasně uvedena na začátku sektoru. Chcete-li to provést, můžete resetovat bit "0" 3 bajty adresy sektoru, tzn. aby byl sudý a vedlejší by měl mít vždy hodnotu 0x00.

Čtení datového bloku.

Algoritmus pro čtení datového bloku je následující:

• Po potvrzení inicializace vyšleme příkaz CMD17 (odpověď R1) s adresou požadovaného sektoru.
• Před přijetím počátečního bajtu 0xFE vysíláme 0xFF.
• Přijímáme datový blok (512 bajtů ve výchozím nastavení) a 2 bajty CRC.

Hodnota CRC není vyžadována, ale je nutná akceptační procedura (převod 0xFF z MK).

Blok čtení.

Napište blok dat.

Algoritmus pro zápis datového bloku je následující:

• Pokud byla karta nečinná déle než 5 ms, odešlete příkaz CMD1 (odpověď R1).
• Po potvrzení inicializace vyšleme příkaz CMD24 (odpověď R1) s adresou požadovaného sektoru.
• Přeneseme počáteční bajt 0xFE.
• Přenášíme datový blok (standardně 512 bajtů) a 2 bajty CRC.
• Obdržíme bajt potvrzení zápisu.
• Čekáme na konec nahrávání (změna bajtu 0x00).

Při změně délky bloku příkazem CMD16 může být datový blok menší než 512 bajtů.

Hodnota CRC není vyžadována, ale postup pro předávání jakýchkoli hodnot je nezbytný.

Posouzení prostojů nemůžete provést programově, ale okamžitě vydat inicializační příkaz. Během implementace softwaru jsem narazil na nesprávný záznam, z nějakého důvodu byly všechny bajty zapsány do sektoru s posunem doleva. Problém byl vyřešen pouze dvojnásobným přenosem start bitu (0xFE).

Blokovat nahrávání.

Potvrzovací bajt při zápisu datového bloku.

Zápis/čtení několika bloků za sebou.

Pomocí příkazů CMD18, CMD25 můžete číst/zapisovat několik bloků za sebou nebo tzv. multiblokové čtení/zápis. Pokud nebyl zadán počet bloků, lze proces čtení/zápisu zastavit pomocí příkazů CMD12 během čtení a také předáním " Zastavte Tran“ při odpovídajícím záznamu.

Praktické použití.

Praktické využití paměťových karet je poměrně široké. Ve svém nejnovějším návrhu použil microSD k záznamu hodnot z různých senzorů (teplota, alarm) po celý den každou hodinu. Data se ukládají následovně:

• Rok se bere z posledních dvou číslic – to odpovídá prvnímu (hlavnímu) bytu adresy sektoru paměťové karty.
• Měsíc, dvě číslice – to odpovídá druhému, nejvýznamnějšímu bajtu adresy sektoru paměťové karty.
• Den, dvě číslice se násobí 2 (aby se zabránilo zásahu mimo hranice sektoru) – toto je třetí, prostřední bajt adresy sektoru paměťové karty.
• Čtvrtý bajt nižšího řádu je vždy "0".

Díky tomu je vyhledávání dat podle data zjednodušeno, stačí požadavek přeložit na adresu sektoru a načíst z karty. Díky této metodě lze data uchovávat několik let. Pravda, existují i ​​nevýhody, zbývá spousta nevyužitého místa. I když, pokud si to přejete, můžete jej použít pro jiné úkoly.

Kdo to potřebuje, pošlu vám fragment kódu v assembleru pro 18 vrcholů.

Dotazy lze pokládat na..

Co si pamatuji, vždy jsem rád četl, ale tohle je 21. století a potřebná literatura se občas dá sehnat jen na internetu. Ano, a e-knihy můžete číst na elektronickém zařízení, jako je tablet, počítač nebo elektronická čtečka. Výsledkem je malé zařízení, které umí číst textové soubory z SD nebo microSD karty a zobrazovat jejich obsah na obrazovce.

Mozkem zařízení je mikrokontrolér Atmega32 pracující na frekvenci 8 MHz. MK je taktován z externího quartz na 8 MHz, jako obrazovku zařízení jsem použil malý LCD indikátor WH1604A na ovladači HD44780 s rozlišením 4 řádky po 16 znacích. Použil jsem běžná tlačítka hodin, pokud jde o SD kartu, pro připojení k mikrokontroléru jsem použil odporové děliče, aby odpovídaly logickým úrovním.

Schematické schéma zařízení:

Pinout ve schématu je správný pouze pro SD kartu nebo SD adaptér, pro připojení dalších karet použijte jejich pinout!

Zařízení podporuje paměťové karty SD, miniSD a microSD až do velikosti 4 GB formátované v souborovém systému FAT, FAT16. Je třeba si uvědomit, že zařízení nepodporuje adresáře, takže všechny soubory je třeba zapsat pouze do kořenového adresáře flash disku. Textové soubory musí být v běžném formátu txt a bez formátování, názvy souborů nesmí být delší než 8 znaků (bez přípony).

Po zapnutí zařízení se na displeji zobrazí úvodní obrazovka:

Pokud SD karta není v zařízení nainstalována, je připojena nesprávně nebo něco jiného, ​​zobrazí se následující zpráva:

Pokud je vše v pořádku, zobrazí se hlavní nabídka:

Pomocí tlačítek můžete vstoupit do položky „Procházet soubory“, kde můžete vybrat soubor, který si potřebujete přečíst.

V položce "Nastavení" si můžete vybrat, jakou příponu chcete zobrazit soubory v "Prohlížeči souborů".

A v posledním odstavci „O systému...“ si můžete přečíst informace o zařízení, jeho autorovi atd.

Firmware pro zařízení jsem napsal v prostředí BASCOM-AVR pomocí knihovny AVRDOS, firmware zabírá pouze 30 % programové paměti mikrokontroléru, takže prostor pro kreativitu je. Uvnitř je zařízení sestaveno na dvou deskách plošných spojů: na jedné je MK s body kitem, na druhé je konektor pro SD kartu a odpovídající řetězce logických úrovní.

Zde je fotka zařízení uvnitř:

Pro napájení jsem použil Ni-Cd baterii 4,8V, 600mAh. Po bliknutí mikrokontroléru je třeba nastavit následující pojistkové bity:

Seznam radioprvků

Označení	Typ	Označení	Množství	Poznámka	Prodejna	Můj poznámkový blok
U1	MK AVR 8bit	ATmega32	1			Do poznámkového bloku
D1, D2	Usměrňovací dioda	1N4001	2			Do poznámkového bloku
C1, C2	Kondenzátor	22 pF	2			Do poznámkového bloku
C3	Elektrolytický kondenzátor	100 uF	1			Do poznámkového bloku
C4	Kondenzátor	100 nF	1			Do poznámkového bloku
R1	Rezistor	10 kOhm	1			Do poznámkového bloku
R2-R4	Rezistor	4,7 kOhm	3			Do poznámkového bloku
R5-R7	Rezistor	1 kOhm	3			Do poznámkového bloku
LCD1	LCD displej	LM014L	1			Do poznámkového bloku
X1	Křemen	8 MHz	1			Do poznámkového bloku
	Knoflík		4			Do poznámkového bloku
	Přepínač		1

Aktualizováno 18. 12. 2015. Ahoj všichni. Dnes budeme pokračovat ve vývoji správce sběru dat, konkrétně ukládání informací přímo na SD karta . V minulém článku byl zaveden provoz teploměru. Nyní tyto informace včas při připojení PROTI další hodiny reálného času (článek č. 29), vložíme jej na paměťovou kartu, čímž získáme jakousi databázi. A také v budoucnu budeme tyto informace přenášet do PC (článek č. 42), do databáze s MySQL (článek č. 48), prostřednictvím malé aplikace v Javě (článek č. 44). Nejprve si ale ujasněme, co je to karta SD a jak s ní pracovat.Začněme stručnou historií. Předchůdce paměti Flash je jedním z energeticky nezávislých typů pamětí, typu, který se osvědčil a používá se v mikrokontrolérech. Flash paměť vznikla z potřeby zvýšení kapacity a změn v technologii mazání (v případě paměti EPROM). Proto v roce 1984 inženýr společnosti Toshiba Fujio Masuokoi změnil technologii mazání, která zase vyřešila nedostatky předchůdců Flash pamětí. Doplňuji, že dále se tato paměť začala dělit podle vnitřního zařízení pro spojování buněk do pole a algoritmů čtení a zápisu - jedná se o technologie NOR a NAND. A také rozdíl v počtu uložených bitů v elementární buňce. Jedná se o SLC zařízení (single-levelcell), tzn. jednobitové buňky rozlišují pouze dvě úrovně nabití na plovoucí bráně. A zařízení MLC (multi-levelcell) - vícebitové buňky rozlišují více úrovní nabití. Druhý typ zařízení je levnější a prostornější než SLC zařízení, ale s delší přístupovou dobou a menším maximálním počtem přepisů (cca 10 tisíc a 100 tisíc u SLC).

Obecně platí, že zařízení technologie NOR jsou dvourozměrná matice vodičů, která umožňuje rychlejší přístup ke každé paměťové buňce, ale oblast buňky je považována za velkou, takže tato technologie se používá pro paměť programu mikroprocesoru a pro ukládání malých pomocných dat a specializovaných zde mohou být také zahrnuty čipy pro spouštění počítače(POST a BIOS), DSP procesory a programovatelná logika Typické objemy - od 1 KB do 1 MB.
Druhým typem zařízení je technologie NAND – trojrozměrné pole má malou plochu buněk, ale poměrně dlouhý přístup k velké skupině buněk najednou. Používá se pro velké množství paměti.Toto je paměť, se kterou budeme pracovat.
Ale předtím bych chtěl mluvit o nevýhodě. Stejně jako vše má své vlastní datum vypršení platnosti, paměť má také zdroj opotřebení. Výrobci v závodě o kapacitu a vedoucí postavení na trhu vždy postrádají takový ukazatel, jako je kvalita, protože... není kompatibilní s vysokou cenou. Takže, když se vrátím k opotřebení, rád bych poznamenal, že životnost informací při použití zařízení MLC je přibližně 5 let, což je spojeno s akumulací nevratných změn při změně náboje. Pokud vezmeme NAND paměti ze SLC zařízení, pak jsou kvalitnější a tedy dražší. Stojí za zmínku, že životnost informací do značné míry závisí na teplotě, gama záření a vysokoenergetických částicích.
Výše bylo řečeno, že nevýhodou karty je omezený počet přepisovacích cyklů. Když ke správě souborů používáme souborový systém, musíme vědět, že takové systémy zapisují data na jedno místo, čímž přirozeně spotřebovávají zdroje přidělené oblasti, případně je činí nepoužitelnými a odpovídajícím způsobem snižují kapacitu. Tento typ paměti využívá NAND řadič, který by měl opotřebení rovnoměrně rozložit. Pro snížení nákladů na zařízení však nesmí být použit řadič a jeho práci bude provádět softwarový NAND ovladač v operačním systému. Po tomto objevu začalo mnoho společností vyvíjet vlastní standardy pro přenosné karty.

Dále přejdeme k pohledu na mapu.
Secure Digital Memory Card (SD) je formát paměťové karty určený pro použití především v přenosných zařízeních. Pro pochopení jeho fungování použijeme specifikaci, která tento standard popisuje a jmenuje se SD Specifications ver3.01.
První věc, kterou potřebujeme, je zjistit, jak s touto kartou pracovat, jak ji připojit atd. Nejprve si vybereme kartu. Pro experimenty jsem si vzal 2GB microSD, standardní kapacitu SDSC. Sběrnice karet může pracovat pomocí dvou protokolů: SD a SPI. Rád bych poznamenal, že tato karta je jakousi modifikací karty MMC, kde (u karty SD) byla hlavní pozornost věnována bezpečnostnímu systému. Proto je operační algoritmus pro protokol SPI stejný a samozřejmě jsou jednosměrně kompatibilní. To znamená, že do slotu pro SD kartu můžeme vložit MMC, ale ne naopak.

Níže uvedený obrázek ukazuje schéma zapojení SD karty protokol SPI .
Toto rozhraní umožňuje výměnu dat vysokou rychlostí za použití minimálního počtu pinů mikrokontroléru, které jsou vybaveny modulem SPI. Od této chvíle začneme používat specifikaci. První, co nás zajímá, je volba režimu. Podívejme se na jemnosti na obr. Níže v části 6.4.1.1 je schéma napájecího napětí a sekvence odesílání příkazu. Zde je jasně vidět, že po zapnutí karty je potřeba počkat pár milisekund (1ms + od 0,1 do 35 ms (rostoucí)) na stabilizaci. Během této doby musí být na linku CS, MOSI přiveden 1. Dále nastává inicializační zpoždění maximálně 1 ms při přivedení 74 pulzů (cyklů) na vstup CLK, po kterém musí následovat příkaz CMD0. Přejděme ke kapitole 7, kde je jasně popsán sled akcí.

Schéma napájecího napětí

Protokol SPI je zvolen po zapnutí napájení a vydání příkazu CMD0 reset. Samotná SD karta pracuje v režimu SD. Do režimu se vstupuje, pokud je při vydání příkazu CMD0 signál SC 0. Při přepnutí do režimu SPI bude karta reagovat ve formátu R1 (obrázek níže). Formát odpovědi je bajt (v závislosti na příkazu, viz tabulka 7.3 ve specifikaci) s příznaky, které určují stav karty. Správné odpovědi pro nás budou 1 (v případě příkazu CMD0) a 0 ve všech ostatních případech.
1. bit – pohotovostní režim
2. – chyba mazání
3. – neznámý tým
4. – chyba týmu
5. – chyba v sekvenci mazání
6. – chyba adresy
7. – chyba argumentu

Během procesu resetování by karta měla odpovědět 0x01, což odpovídá prvnímu bitu.

Ve specifikaci je jasné pořadí inicializace pro SPI. Proč se používá příkaz CMD8 ke kontrole pracovního stavu karty, kde probíhá poměrně složitý ověřovací algoritmus. Následuje příkaz CMD58 pro určení typu karty SDSD nebo SDHC a SDXC. A také příkaz CMD41 pro spuštění a kontrolu inicializace. Je to poměrně komplikovaný proces inicializace s kontrolami, ale myslím si, že pro jednoduchý záznam dat lze použít i jednodušší proces. V části 7.2.7. Uvádí se, že v pohotovostním režimu jsou platné pouze příkazy pro kartu CMD41, CMD8, CMD58, CMD59, stejně jako pro paměťové karty SD (tl. 2,1 mm) CMD1, který je shodný s příkazem CMD41. Ve standardu je tento příkaz považován za zakázaný pro inicializaci a používá se výhradně k rozlišení mezi kartami 1,4 mm a 2,1 mm.
Vezměme si jednodušší cestu a použijeme příkaz CMD1. Vše popsané výše zobrazíme v kódu v inicializační funkci, ale ještě předtím zvážíme formát příkazu. Každá instrukce nebo datový blok se skládá z osmi bitových bajtů, které jsou zarovnány se signálem CLK. Tito. každá instrukce je zarovnána na hranici 8 hodinových cyklů. Zprávy SPI se skládají z příkazů, odpovědí a dat. Veškerá komunikace je řízena mikrokontrolérem. Všechny příkazy jsou dlouhé 6 bajtů. Přenos začíná prvním levým bitem.

Níže uvedený obrázek ukazuje formát příkazu.

Start bit - Jakýkoli příkaz začíná od 0.Přenášený bit je také vždy roven 1.

Index – přímo vysílaný příkaz.

Argument- Pro každý příkaz je argument uveden v tabulce specifikací.

CRC kontrola redundance kódu. Ve výchozím nastavení je v režimu SPI zakázána. Používáme jej tedy pouze pro příkaz CMD0, který se odesílá před vstupem do režimu a má hodnotu CRC 0x95.

Stop bit - konec vysílaného příkazu.

Začněme tedy psát kód.

Začněme nezbytnými 2 funkcemi: vysílání a příjem bajtů.

1. Přeneste bajt na kartu.

void trans_byte_sd (data nepodepsaného znaku) // předá pole bitů

{

pro (znak bez znaménka i=0;i<8;i++) //Iterace přes byte

{

if ((data&0×80)==0×00)//Pokud je nejvýznamnější bit = 0

PORTB&=~_BV (PB3);//Nastav MOSI (DI) -0

jiný

PORTB|=_BV (PB3);//1

data=data<<1; // сдвиг влево

PORTB|=_BV (PB5); //Puls nebo stroboskop

asm("ne"); //Pauza 1 úder

PORTB&=~_BV (PB5);

}

}

2. Příjem bajtu mikrokontrolérem.

nepodepsaný znak příjem_byte_sd (neplatný) // Vraťte odpověď

{

unsigned char data = 0; // inicializovat pole

for (znak bez znaménka i=0; i<8; i++)

{

PORTB|=_BV (PB5); //Pulzní hrana

data=data<<1; // Shift doleva

if ((PINB&_BV (PB4))!=0×00) // Pokud je stav pinu 1

data=data|0×01;

PORTB&=~_BV (PB5); //0

asm("ne");

}

vrátit data; // Vraťte odpověď

}

Od výše popsaných základních funkcí začneme psát další kód. Dále napíšeme funkci přenosu příkazu. Zde bych chtěl upozornit na skutečnost, že můžete předat všech 5 argumentů: přímo samotný příkaz a 4 argumenty odpovědné za adresu paměťových buněk samotné karty. Pokud jde o 6. bajt, pak CRC při vstupu do režimu SPI je zakázáno (ve výchozím nastavení) a hodnota je trvale nastavena na 0x95, což se používá pouze pro CMD0, když karta není v režimu. Kontrolu kódu můžete povolit pomocí příkazu CMD58. Pro experiment předávám dva argumenty.

3.Předání velení.

unsigned char comand_sd (char CMD, char arg) /*předat příkaz a adresu, ke které přistupujeme a vrátit odpověď*/

{

long int i=0; // proměnná pro počítadlo

unsigned char r1; // odpověď karty

trans_byte_sd(CMD); // tým

trans_byte_sd(0×00);

trans_byte_sd(0×00);

trans_byte_sd(arg); // přenos adresy

trans_byte_sd(0×00);

trans_byte_sd(0×95); // Odeslání CRC

/* Po odeslání příkazu čekáme na odpověď ve formátu R1 Každý příkaz má svou odpověď */

/* Smyčka pro čekání na odpověď po určitou dobu */

dělat

{

r1=receive_byte_sd();

i++;

)zatímco (((r1&0×80)!=0×00)&&(i<0xffff)); /* Pokud nejvýznamnější bit bajtu není 0 a i nepřekročí 65 535 hodinových cyklů */

návrat r1; // Vraťte odpověď

}

4. A inicializace karty.

Nyní můžeme inicializovat mapu. Program je stručně popsán následovně: první věc, kterou musíte udělat, je přepnout kartu do režimu SPI. Po zapnutí napájení se karta přepne do režimu SD. Pro volbu režimu SPI je na vstup CS přivedena logická 0 a současně je na vstup karty MOSI odeslán příkaz k resetování CMD0 a inicializaci CMD1. Upozorňujeme, že příkaz začíná hexadecimálně 0x40, ke kterému musíte přidat číslo příkazu CMD v šestnáctkové soustavě.

nepodepsaný char spi_card_init (neplatný)// funkce vrací odpověď

{

unsigned char r1; // proměnná pro přijetí odpovědi

dlouhé int i =0; // proměnná pro počítadlo

_delay_ms(10); // malé zpoždění pro stabilizaci napětí.

PORTB|=_BV (PB1); //CS, nastaveno na 1, při odesílání hodinových cyklů

PORTB|=_BV (PB3); //příkazový řádek - 1 MOSI (DI)

for (znak bez znaménka i=0; i<80;i++) // odeslat více než 74 impulsů

{

PORTB|=_BV (PB5); //CLK - 1

asm("ne"); //zpoždění o jednu hodinu

PORTB&=~_BV (PB5); //CLK - 0

}

PORTB&=~_BV (PB1); /* podmínka pro vstup do režimu SPI CS řádek by se mělo rovnat 0 */

r1=comand_sd (0×40,0×00); // CMD0=0×40, na adrese nezáleží

if (r1!=0×01) return 4;//můžete nastavit libovolné chybové kódy

trans_byte_sd(0xff); /* poslat stroboskop, druh pauzy před obdržením odpovědi */

dělat // cyklus přijímání odpovědi z karty

{

r1=comand_sd (0×41,0×00); /* odešlete inicializační příkaz */

trans_byte_sd(0xff); // pauza

i++; // čítač

)zatímco ((r1!= 0)&&(i<65535)); /*dokud není přijata odpověď 0 a počet cyklů nepřekročí 0xffff */

if (i>=0xffff) return 5; /* vrátí chybu, pokud čas dotazování překročí */

návrat 0; //Pokud je inicializace úspěšná, vrátí 0

}

Dalším důležitým bodem je, že specifikace uvádí, že informace jsou přenášeny v blocích po 512 bitech, a pokud je SDSC karta jako v našem případě, pak lze délku bloku nastavit od 1 do 512 bitů pomocí příkazu CMD16. Výchozí hodnota je 512 bitů. Dále popíšeme dvě funkce pro příjem a vysílání bloků. Specifikace obsahuje bloková schémata, na základě kterých budeme kód psát.

Přenos bloku informací na kartu.

Příkaz CMD24 je zodpovědný za přenos ONLY bloku. Po zadání příkazu čekáme na odpověď, následuje startovací bajt, který připraví řadič karty na příjem informace, na konci karta odpoví bajtem o stavu přenosu, který je popsán v kapitole 7.3. 3.1. Tito. správná odpověď by měla být = 5. Také čekáme, až se sběrnice uvolní pro další přenos.

Byte zpětné vazby stavu přenosu.

Část 7.3.3.2 popisuje formát přenášeného bloku

unsigned char accept_block_sd (char* block, char arg)/* předáme pole pro záznam dat a adresu, ke které přistupujeme */

{

long int i = 0;

unsigned char r1;

r1=comand_sd(0X51,arg);//CMD17

if (r1!=0×00) vrátí 5;//Konec, pokud odpověď není 0×00

trans_byte_sd(0xff);

dělat //Počkejte na spuštění datového paketu

{

r1=receive_byte_sd();

i++;

)zatímco ((r1!= 0xfe)&&(i<65535));

if (i>=0xffff) return 5;

pro (int i=0;i<512;i=i+1) //příjem dat

block[i] = příjem_byte_sd();

příjem_byte_sd(); //bajt CRC

příjem_byte_sd(); //bajt CRC

návrat 0;

}

Před použitím programu se podívejme na hardware. Jak jsme si řekli výše, karta je kompatibilní s mikrokontrolérem v režimu SPI. Všimněme si následujících nuancí práce s mapou:
1. Párování logických úrovní je nutné pro různá napájecí napětí SD karty a mikrokontroléru AVR. Můžete použít odporový dělič napětí, který je lineární, tzn. Výstupní napětí závisí na vstupním napětí. Nebo můžete mít paralelní parametrický stabilizátor napětí na zenerově diodě, stejný jako u první možnosti, jen ve spodním rameni je použita zenerova dioda, která je nelineární dělič a díky svým vlastnostem hlídá referenční napětí, kdy vstup napětí se zvyšuje, snižuje se vnitřní odpor a naopak.
Použil jsem druhou možnost. V obvodu níže na signálovém vedení jsou odpory předřadné (omezovače proudu), na vstup děliče je přivedeno napětí 4,5 - 5 V a výstup je odstraněn ze spodního ramene děliče.Omezovače proudu jsou nezbytné pro ochranu karty a dalších periferií v případě selhání mikrokontroléru. U dobře fungujícího zařízení nejsou nutné.

Všimněte si, že linku MISO není nutné vyjednávat, protože Funguje pouze jedním směrem od karty k mikrokontroléru.
2. Druhý bod, nepoužívám kontroly dostupnosti karty a ochrany proti zápisu. Někteří lidé mají tyto kontakty ve slotech, někteří ne.
3. Posledním bodem je jídlo. Buďto do celého obvodu včetně mikrokontroléru napájíte 3,3V, nebo dáte na vstup obvodu děličku, která není příliš spolehlivá. Nebo stabilizátor 3,3 V, jako jsem to udělal na čipu LP2980 . Důležitým bodem je zde elektrolytický (tantalový) kondenzátor, který chrání mikrokontrolér před resetováním při poklesech napětí.
Níže je uveden program a výsledek.Jako vždy se snažím používat jeden program a neustále ho měnit. Tento kód je převzat z článku č. 5 (sedmisegmentový indikátor).

#zahrnout

#zahrnout

#zahrnout

#zahrnout

//makra pro práci s indikátorem

#definujte 128

#definujte b 32

#definujte od 8

#definujte d 2

#definujte e 1

#definujte f 64

#definujte g 16

#definujte dp 4

// Proměnné

char block =();//vyrovnávací paměť pro zápis/čtení dat na kartu

short unsigned int j, k = 0; //v makru přerušení

nepodepsaný znak Slot; // Pole čísel k zobrazení na indikátoru

//Deklarace funkcí

void trans_byte_sd (data nepodepsaného znaku);// funkce přenosu bajtů

unsigned char příjem_byte_sd (neplatný); //Funkce příjmu bajtů

unsigned char comand_sd (char,char); // funkce přenosu příkazů

unsigned char spi_card_init (void); //Funkce inicializace paměťové karty

unsigned char accept_block_sd (char* block, char arg); //Zablokujte funkci příjmu

unsigned char trans_block_sd (char* blok, char arg); //Zablokujte funkci přenosu

// Inicializace indikátoru

void Slot_init()

{…………………….};

// Proměnné pro zobrazení čísel

char Elem1, Elem2, Elem3;

// Výstup do indikátoru

prázdný displej (float i)

{ …………………………... }

int main (neplatný) //zahájení základu programu

{

DDRB = 0x2A; //0010 1010 – PB1, PB3, PB5

DDRD = 0xff; //všechny piny portu jsou výstupy

PORTD = 0×00; //nastavit na 0

PORTB |= 0хdb; //1101 1011 (PB0,1,3,4,6,7)

slot_init();

sei(); // nebo SREG |= (1<< 7); разрешить общее прерывание

//inicializace časovače T0

TIMSK = (1</*Povolit příznak pro přetečení časovače čítače T0*/

TCCR0 = (0< //1000000/8 = 125000

unsigned char temp;

int i;

pro (i=0;i<512;i=i+1)

blok[i]= i; //zápis do vyrovnávací paměti

spi_card_init(); //inicializace

trans_block_sd(blok,0×04); //odeslání dat na kartu

//Resetování vyrovnávací paměti na nulu

pro (int i=0;i<512;i=i+1)

blok[i]=0;

// Načtení dat z karty

přijmout_blok_sd(blok, 0×04); ;//Funkce příjmu bajtů

pro (int i=0;i<512;i=i+1)

{

char otv;

otv = blok[i];

Display(otv);

_delay_ms(100);

}

//Zápis na adresu paměti 0

pro (int i=0;i<512;i=i+1)

blok[i]=0;

unsigned char comand_sd (char,0×00); //funkce přenosu příkazů

trans_block_sd(blok,0×04); //odeslání dat na kartu

}

//Výstup do indikátoru

ISR (TIMER0_OVF_vect)

{ ……………. }

Důležitým bodem jsou časové limity. Je důležité sledovat čas potřebný k načtení záznamu a vymazání karty, protože mikrokontrolér může při čekání na odezvu z karty zamrznout. Specifikace jasně popisuje časové limity karty. Karta je v nečinnosti 5 ms, poté přejde do úsporného režimu, ve kterém jsou platné následující příkazy: CMD0, CMD1, CMD41 a CMD58. Při překročení limitu nečinnosti tedy vyšleme CMD1, odezvu a dále pracujeme s kartou.
Níže jsou dva screenshoty z programu WinHex, pomocí kterého můžeme prohlížet obsah paměťových buněk. Program funguje následovně: Zapíšeme data do vyrovnávací paměti, odešleme je na kartu, vynulujeme vyrovnávací paměť, načteme data z karty do vyrovnávací paměti a zobrazíme je na displeji, čímž zajistíme přenos dat na kartu. . Podíváme se na obsah karty, resetujeme vyrovnávací paměť, zapíšeme na kartu 0 a obsah karty znovu otevřeme, čímž se ujistíme, že program a obvod fungují. Jako vždy nezapomínejte na maličkosti, jako je nedostatek pájky, velké praskliny ve stopách atd., které mohou zabrat lví čas. Pokud tedy máte po ruce osciloskop, určitě jej pro nastavení použijte. VČlánek č. 24Uvedl jsem malý příklad diagnostiky karty ve všech fázích jejího fungování.setkáme sesenzor vlhkosti a teplotyDHT11. Poté začneme zaznamenávat data (teplotu a vlhkost) do textového souboru, jakési databáze. To je prozatím vše. Ahoj všichni.