Az SD kártya csatlakoztatása avr
Ezután menjünk közvetlenül a térképre.
A biztonságos digitális memóriakártya (SD) egy memóriakártya formátum, amelyet elsősorban hordozható eszközökön használnak. Ahhoz, hogy megértsük a munkáját, a szabványt leíró specifikációt fogjuk használni, és az SD Specification ver3.01-nek nevezzük.
Az első dolog, amire szükségünk van, hogy kitaláljuk, hogyan kell dolgozni ezzel a kártyával, hogyan kapcsolódjunk össze és dolgozzunk. Először választunk ki egy kártyát. Kísérletekben egy microSD-t használtam, amelynek kapacitása 2 GB volt, a standard SDSC kapacitás. A kártya busz két SD és SPI protokollon dolgozhat. Szeretném megjegyezni, hogy ez a kártya az MMC kártya egyfajta módosítása, ahol (az SD-kártyán) a legnagyobb figyelmet fordították a biztonsági rendszerre. Ezért az SPI protokollon végzett algoritmus ugyanaz, és természetesen egyoldalúan kompatibilis. Így be tudjuk illeszteni az MMC-t az SD kártyanyílásba, de nem fordítva.
Az alábbi ábra mutatja az SD kártya SPI protokoll használatát.
Ez az interfész nagy sebességű adatcserét tesz lehetővé a mikrokontroller minimális számának használatával
Tápegység diagram
Az alaphelyzetbe állításkor a kártya 0 × 01-nek kell válaszolnia, ami az első bitnek felel meg.
A specifikációnak egyértelmű inicializálási sorrendje van az SPI számára. Ebből a célból a CMD8 parancs segítségével ellenőrizheti a kártya működési állapotát, ahol meglehetősen egyszerű ellenőrző algoritmus történik. Ezután a CMD58 parancs határozza meg az SDSD vagy SDHC kártya és az SDXC típusát. És a CMD41 parancs is az inicializálás megkezdéséhez és ellenőrzéséhez. Egy meglehetősen egyszerű inicializálási folyamat ellenőrzéssel, de azt hiszem, hogy az egyszerűbb adatíráshoz egyszerűbb folyamatot használhat. A 7.2.7. hogy készenléti állapotban a kártyára csak a CMD41, a CMD8, a CMD58 és a CMD59 parancsok érvényesek. és kártyákhoz (vastag 2,1 mm-es) SD memória CMD1, ami azonos a CMD41 paranccsal. A szabvány szerint ez a parancs inicializálásra tilos, és kizárólag az 1.4 mm és 2.1 mm kártyák közötti különbségre használható.
Menjünk könnyebben és használjuk a CMD1 parancsot. A fentiek mindegyike megjelenik a kódban az inicializálás funkcióban, de előtte megnézzük a parancs formátumát. Minden parancs vagy adatblokk nyolc bit byte-ból áll, amelyek a CLK jelhez igazodnak. Ie minden csapat a 8-as méretű határ mentén helyezkedik el. Az SPI üzenetek egy parancsból, válaszból és adatokból állnak. Minden kommunikációt mikrokontroller vezérel. Minden parancs 6 bájt hosszúságú. Az átvitel az első bal oldali bittel kezdődik.
Az alábbi ábra mutatja a parancs formátumát.
Indítsa el a bitet - a 0-tól minden parancs elindul. A továbbított bit is mindig 1.
Az index egy közvetlenül továbbított parancs.
Argumentum - minden parancs esetében az argumentumot a specifikációs táblázatban adjuk meg.
CRC - kód redundanciaellenőrzés. Alapértelmezés szerint SPI módban le van tiltva. Ezért csak a CMD0 parancsra használjuk, amelyet elküldünk az üzemmódba való belépés előtt, és értéke 0 × 95 CRC.
Stop bit - a továbbított parancs vége.
Hát, kezdjük el írni a kódot.
Kezdjük a szükséges 2 funkcióval: egy byte küldésével és fogadásával.
1. Húzza át a byte térképet.
void trans_byte_sd (unsigned char data) // pass bit array
az (unsigned char i = 0; i<8;i++) //Перебираем байт
ha ((data0 × 80) == 0 × 00) // Ha a legjelentősebb bit 0
visszatérési adatok; Visszaadja a választ
3. A csapat továbbítása.
hosszú int i = 0; // a számláló változója
aláíratlan char r1; // térképre adott válasz
transz_byte_sd (CMD); // parancs
trans_byte_sd (0 × 00);
trans_byte_sd (0 × 00);
trans_byte_sd (0 × 00);
transz_byte_sd (0x95); // Transzfer CRC
/ * Miután elküldtük a parancsot, várjuk az R1. formátum válaszát. Mindegyik csapat saját választ kap * /
/ * Hurok vár egy válaszra egy bizonyos időre * /
r1 = receive_byte_sd ();
> míg (((r10 × 80)! = 0 × 00) (i<0xffff)); /* Как только старший бит байта не равен 0 и i не превышает 65 535 тактов*/
return r1; Visszaadja a választ
4. És a térkép be van szegezve.
Most regisztrálhatjuk a kártya inicializálását. Röviden a program leírása a következő: az első dolog, amire szüksége van, hogy a kártyát SPI módba. A tápellátás bekapcsolt állapotában a kártya SD módba van állítva. Az SPI mód kiválasztásához a CS bemeneten logikai 0 kerül beadagolásra, ugyanakkor a CMD0 reset parancs és a CMD1 inicializálás bemeneti a MOSI kártya bemenetére. Ne feledje, hogy a parancs egy hexadecimális 0 × 40-vel kezdődik, amelyhez a CMD parancsszámot hexadecimálisan kell hozzáadni.
az unsigned char spi_card_init (void) // függvény visszaküldi a választ
aláíratlan char r1; // a változó, hogy megkapja a választ
hosszú int i = 0; // a számláló változója
_delay_ms (10); // egy kis késleltetés a feszültség stabilizálására.
PORTB | = _BV (PB1); // CS, állítsa 1-re, amikor rudakat ad
PORTB | = _BV (PB3); // parancssor - 1 MOSI (DI)
az (unsigned char i = 0; i<80;i++) // посылаем более 74 импульса
PORTB | = _BV (PB5); // CLK-1
asm ("nop"); // egy ciklus késleltetés
PORTB =
_BV (PB5); // CLK - 0
PORTB =
_BV (PB1); / * az SPI módú CS vonal beírásának feltétele 0 * /
ha (r1! = 0 × 01) visszatér 4; // a hibakódok bármit fel tudnak tenni
trans_byte_sd (0xff); / * küldjön egy strobe-t, egyfajta szünetet mielőtt megkapja a választ * /
/ / kap egy választ a kártyától
r1 = comand_sd (0 × 41,0 × 00); / * elküldi az inicializálási parancsot * /
trans_byte_sd (0xff); szünet
i ++; // számláló
amíg ((r1! = 0) (i<65535)); /*пока не получен ответ 0 и количество циклов не превышает 0xffff */
ha (i> = 0xffff) visszatér 5; / * hiba visszatérése, ha meghaladja a lekérdezési időt * /
visszatérés 0; // A sikeres inicializálás esetén a 0 értéket adja vissza
A specifikációban a következő fontos pont az, hogy az információt 512 bites blokkokban továbbítják, és ha az SDSC kártya megegyezik a mi esetünkben, akkor a CMD16 parancs segítségével a blokkhossz 1-től 512 bitre állítható. Az alapértelmezett érték 512 bit. Ezután két funkciót ismertetünk blokkok fogadására és továbbítására. A specifikációban blokkdiagramokat adunk meg, amelyek alapján megírjuk a kódot.
Vigye át az információblokkot a kártyára.
A SINGLE egység átvitelére a CMD24 parancs válaszol. A parancs kiadása után várjuk a választ, majd a kártya vezérlőnek az információ fogadására felkészítő indító bájtja követi, a végén a kártya a távadási állapotról egy byte-ot válaszol, amelyet a 7.3.3.1 fejezet ír le. Ie a helyes válasznak = 5-nek kell lennie. Továbbá várakozunk a gumiabroncs felszabadítására további átvitel céljából.
Visszajelzési bájt az átviteli állapotért.
A 7.3.3.2. Szakasz leírja a továbbított blokk formátumát
5. Az információs blokk továbbítása.
hosszú int i; // számláló
aláíratlan char r1; // válasz
r1 = comand_sd (0 × 58, arg); // CMD24
ha (r1! = 0 × 00) visszatér 6; // output, ha a válasz nem 0
trans_byte_sd (0xff); // rövid szünet
trans_byte_sd (0xfe); // start byte
az (int i = 0; i<512;i++) //передаем данные
trans_byte_sd (blokk [i]);
trans_byte_sd (0xff); // CRC byte
trans_byte_sd (0xff); // CRC byte
r1 = receive_byte_sd (); // megerősítő byte-t kap
ha ((r10 × 05)! = 0 × 05) visszatér 7; // ellenőrizze a helyes átvitelt
// várjon a busz felszabadítására
r1 = receive_byte_sd ();
amíg ((r1! = 0xff) (i<65535));
ha (i> = 0xffff) visszatér 8;
visszatérés 0; // visszaadása 0, ha sikeres
6. És az utolsó függvény a blokk olvasását jelenti. Az eljárás lényegében ugyanaz, mint az átvitelnél, csak a vételhez: először az indító bájtot, majd 512 bitet és 2 bájtot a kódellenőrzéshez. Ne feledje, még ha a CRC le van tiltva, még 2 bájtot kell küldeni és fogadni. Egy ilyen blokk formátum.
hosszú int i = 0;
aláíratlan char r1;
r1 = comand_sd (0X51, arg); // CMD17
ha (r1! = 0 × 00) visszatér 5; // Kilépés, ha a válasz nem 0 × 00
trans_byte_sd (0xff);
do // Várakozunk az adatcsomag kezdetére
r1 = receive_byte_sd ();
amíg ((r1! = 0xfe) (i<65535));
ha (i> = 0xffff) visszatér 5;
az (int i = 0; i<512;i=i+1) //прием данных
blokk [i] = receive_byte_sd ();
receive_byte_sd (); // CRC byte
receive_byte_sd (); // CRC byte
visszatérés 0;
A program használata előtt nézzük meg a hardver részt. Amint azt korábban említettük, a kártya SPI módban kompatibilis a mikrokontrollerrel. Ne feledje, hogy a kártyával való munkavégzés során a következő dolgok fordulnak elő:
1. A logikai szintek összekapcsolása az SD kártya és az AVR mikrokontroller különböző tápfeszültségéhez szükséges. Lehetséges egy lineáris lineáris rezisztív feszültségelosztó alkalmazása, pl. A kimeneti feszültség a bemeneti feszültségtől függ. Egy párhuzamos lehet parametrikus Zener feszültség szabályozó, valamint azt is, hogy az első kiviteli alak csak az alkar a Zener dióda használnak, amely egy nem-lineáris elválasztó, és figyeli a referencia feszültség miatt tulajdonságait növeli a bemeneti feszültség, hogy csökkentsék a belső ellenállás, és fordítva.
A második lehetőséget használtam. Az alábbi ábrán a jel vonalak előtét ellenállás (áramkorlátozó), az input a elválasztó feszültség 4,5 - 5 V, és a kimenet eltávolítjuk egy alsó válla elválasztó. Az áramkorlátozóknak meg kell védeniük a kártyát és más perifériákat, miközben mikrokontroller meghibásodik. Jól hangolt eszközzel nem szükséges.
Ne feledje, hogy a MISO vonal nem igényel koordinációt; A kártyától a mikrokontrollerig csak egyféle módon működik.
2. A második pont, nem használom a kártya ellenőrzését és írásvédelmét. Valakinek van ilyen kapcsolatuk a résidőkben, valaki nem.
3. Az utolsó pillanatban az étel. Vagy 3,3 V-ot táplálsz az egész áramkörbe, beleértve a mikrokontrollert is, vagy pedig az osztót az áramkör bemenetére helyezzük, nem túl megbízhatóan. Vagy a stabilizátor 3.3 volt, mint az LP2980 chipen. Fontos pont itt egy elektrolitikus (tantál) kondenzátor, amely megvédi a mikrokontrollert a dömpingtől, ha feszültségcsökkenés van.
Az alábbiakban a program és az eredmény. Mint mindig, megpróbálok egy programot folyamatosan változtatni. Ez a kód az 5. cikkből (hét szegmensjelző) származik.
#include
#include
#include
#include
// makrók az indikátorral való munkavégzéshez
#define a 128
#define b 32
#define c 8
#define d 2
#define e 1
#define f 64
#define g 16
#define dp 4
char blokk [512] =<>; // írni / olvasható puffer a térképhez
rövid alá nem írt int j, k = 0; // a megszakítási makróban
unsigned char Slot [11]; // A kijelzőn megjelenő számok sorozata
void trans_byte_sd (unsigned char data); // byte átviteli függvény
unsigned char receive_byte_sd (void); // Byte függvény
unsigned char comand_sd (char, char); // a parancs átadásának funkciója
unsigned char spi_card_init (üres); // Memóriakártya inicializáló funkció
unsigned char receive_block_sd (char * blokk, char arg); // A blokk fogadásának funkciója
unsigned char trans_block_sd (char * blokk, char arg); // Block transfer function
Indítsa el a mutatót
void Slot_init ()
// Kimenet a kijelzőre
ISR (TIMER0_OVF_vect)
Fontos pont az időtúllépések. Fontos figyelni a felvétel leolvasásának és a kártya törlésének időtartamát, mivel a mikrokontroller a kártya válasz várakozási üzemmódjában lóghat. A specifikáció egyértelműen leírja a kártya időtúllépését. Egy egyszerű kártya 5 ms-ot igényel, ezután energiatakarékos módba kerül, amelyben a következő CMD0, CMD1, CMD41 és CMD58 parancsok érvényesek. Ezért ha az üresjárati túllépés meghaladja a CMD1 átvitelét, akkor a válasz tovább feldolgozásra kerül a kártyával.
Az alábbiakban két WinHex program screenshotja található. amellyel megnézhetjük a memóriacellák tartalmát. A program a következőképpen működik: Adatot írunk a pufferbe, elküldi a kártyát, zérja le a puffert, olvassa el az adatokat a kártyáról a pufferbe és megjeleníti azt, ezzel biztosítva, hogy az adatok a kártyára kerüljenek. Megnézzük a térkép tartalmát, visszaállítjuk a puffert, írunk 0-at a térképre, és újra megnyitjuk a térkép tartalmát, ezzel biztosítva, hogy a program és az áramkör működjön. Mint mindig, felejthetetlenné válik a kicsit, mint például a dopajka, nem pedig a nagy horgolók az utakon stb., Amelyek elvesznek az oroszlánrészidőt. Ezért, ha van egy oszcilloszkóp kéznél, akkor biztosan használd a beállításhoz. A 24. cikkben kis példát adtam a térkép diagnosztizálására a munka minden szakaszában.
