SD-kortprotokoll. Secure Digital (SD) kortstift

Som kan ses i figuren, efter att kommandoramen har sänts, är det nödvändigt att fortsätta läsa bytes (Ncr) från microSD tills ett svar (R1) tas emot, medan CS-nivån måste vara aktiv "0".

Beroende på kommandoindex kan svaret inte bara vara R1(se grundläggande kommandouppsättning) på CMD58-svar R3(R1 och det avslutande 32-bitars OCR-värdet), och vissa kommandon behöver mer NCR-tid och de kommer att svara R1b. Detta är ett R1-svar följt av en upptagen flagga (signalen på "DO"-linjen hålls låg av kortet medan den interna processen fortsätter). Värdkontrollanten måste vänta till slutet av processen tills "DO" blir hög (dvs vänta på 0xFF). Samt R2 vid begäran om status för STATUS-registret.

R1-svaret innehåller 1 byte, dess struktur kan ses i tabellen nedan. R2-svaret består av två byte, den första byten R1 och den andra R2 (se R2-strukturtabellen). Och svaret R3, respektive, på 5 byte.

R1 svar vid 0x00 betyder framgångsrikt slutförande av kommandot, annars kommer motsvarande flagga att ställas in.

Strukturen för svaret R1.

Strukturen för svaret R2.

Initialisering i SPI-läge.

Efter återställning och påslagning är kortet som standard inställt på MMC (Serial Peripheral Interface) protokollläge, för att växla till SPI-läge, gör följande:

1. Efter att ha nått 2,2 V-matningen, vänta minst en millisekund, ställ in DI- och CS-linjerna högt och ge cirka 80 pulser till CLK-stiftet. Efter denna procedur kommer kortet att vara redo att acceptera det infödda laget.
2. Skicka kommando CMD0 (mjuk återställning). Kortet ska svara (R1) med den väntande biten (0x01) inställd.
3. Skicka kommando CMD1 (för att starta kortinitiering). Vänta på ett 0x00-svar för att bekräfta att processen är klar initiering.

Låt mig påminna dig om att CMD0-kommandot måste innehålla rätt CRC-fält. Det är ingen mening att beräkna, eftersom det inte finns några argument i detta kommando, därför är det konstant och har ett värde på 0x95. När kortet går in i SPI-läge kommer CRC-funktionen att inaktiveras och kommer inte att kontrolleras. CRC-alternativet kan återaktiveras med kommandot CMD59.

Som ett resultat kommer kommandot CMD0 att se ut så här: 0x40.0x00.0x00.0x00.0x00.0x95.

• kommandoindex - 0x40.
• argumentet är 0x00.0x00.0x00.0x00.
• CRC-0x95.

När det gäller 80 pulser kan de genereras genom att sända värdet 0xFF via SPI10 gånger i radpå uppsatta höga nivåer på linjerna DI och CS.

Efter att ha varit inaktiv i mer än 5 ms går minneskortet in i ett energisparläge och kan endast ta emot kommandon CMD0, CMD1 och CMD58. Därför måste initieringsprocessen (CMD1) upprepas nästan varje gång när man läser/skriver ett datablock eller kontrollerar kortets status.

För SDC-kort vid kommandoavslagCMD1 rekommenderas för att använda kommandot ACMD41.

Själva initieringsprocessen kan ta relativt lång tid (beroende på kortets storlek) och kan nå hundratals millisekunder.

Läsa och skriva ett datablock.

Som standard, i SPI-läge, utförs utbytet mellan mikrokontrollern och kortet i block på 512 byte, så för att skriva ens en byte måste du först läsa hela blocket och ändra byte för att skriva över det tillbaka. Blockstorleken kan ändras i minneskortets CSD-register.

För att undvika ett adresseringsfel vid exekvering av läs-/skrivkommandon är det nödvändigt att adressen tydligt anges i början av sektorn. För att göra detta kan du återställa bit "0" 3 byte av sektoradressen, dvs. gör det jämnt, och det låga värdet ska alltid vara 0x00.

Läser ett datablock.

Algoritmen för läsning av datablock är som följer:

• Efter att ha bekräftat initieringen skickar vi CMD17-kommandot (svar R1), med adressen till den önskade sektorn.
• Vi skickar 0xFF innan vi tar emot startbyten 0xFE .
• Vi accepterar ett datablock (som standard 512 byte) och 2 byte CRC.

CRC-värdet krävs inte, men godkännandeproceduren (överföring av 0xFF från MCU) krävs.

Blockera läsning.

Skriv ett datablock.

Algoritmen för att skriva ett datablock är som följer:

• Om kortets vilotid var mer än 5 ms, skicka kommandot CMD1 (svar R1).
• Efter att ha bekräftat initieringen skickar vi CMD24-kommandot (svar R1), med adressen till den önskade sektorn.
• Vi skickar startbyten 0xFE .
• Vi skickar ett datablock (som standard 512 byte) och 2 byte CRC.
• Vi får en skrivbekräftelsebyte.
• Vi väntar på slutet av inspelningen (ändringar i byte 0x00).

Datablocket kan vara mindre än 512 byte när du ändrar blocklängden med kommandot CMD16.

CRC-värdet krävs inte, men proceduren för att skicka eventuella värden är nödvändig.

Du kan programmässigt inte utvärdera vilotid, utan omedelbart ge ett initieringskommando. Under mjukvaruimplementeringen stötte jag på en felaktig skrivning, av någon anledning skrevs alla bytes till sektorn med en förskjutning åt vänster. Problemet löstes endast genom att skicka startbiten (0xFE) två gånger.

Blockera rekord.

Bekräftelsebyte vid skrivning av ett datablock.

Skriv/läs flera block i rad.

Med hjälp av kommandon cmd18, cmd25 du kan läsa / skriva flera block i rad eller den så kallade multi-block läsa / skriva. Om antalet block inte har ställts in, kan läs-/skrivprocessen stoppas av CMD12-kommandon vid läsning, såväl som genom att skicka token " Stoppa Tran" vid inspelning, respektive.

Praktisk användning.

Den praktiska användningen av minneskort är ganska bred. I sin senaste design använde han microSD för att registrera avläsningar från olika sensorer (temperatur, larm) varje timme under dagen. Uppgifterna sparas enligt följande:

• Årtalet tas som de två sista siffrorna - detta motsvarar den första (huvud)byten i minneskortets sektoradress.
• Månad, två siffror - detta motsvarar den andra, mest signifikanta byten i minneskortets sektoradress.
• Dag, två siffror multipliceras med 2 (för att undvika kollision utanför sektorgränsen) - detta är den tredje, mellersta byten av minneskortets sektoradress.
• Den lägre, fjärde byten, respektive, är alltid "0".

Som ett resultat förenklas sökningen efter data efter datum, det räcker bara att översätta begäran till sektorns adress och läsa från kortet. Med denna metod kan data lagras i flera år. Det är sant att det finns nackdelar, det finns ganska mycket oanvänt utrymme. Även om du, om så önskas, kan använda för andra uppgifter.

Vem behöver kasta av sig ett kodfragment i assembler för 18 toppar.

Frågor kan ställas på..

Vi visade bilden på displayen från SD-kortet, men några punkter saknades i det, den första - att ansluta själva kortet, den andra - bara en del av biblioteksfunktionerna övervägdes Petit FatFs Låt oss ta en närmare titt på dessa punkter.

Kommunikation med kortet är möjlig via ett av två gränssnitt, SPI eller SD.

Jag måste säga att SD-gränssnittet kan fungera i en-bitars och fyra-bitars lägen.

Schemat för att ansluta kortet via SPI är standard och ser ut så här, oanvända kortstift måste anslutas till strömförsörjningen med ett 10K-motstånd.

Men i amatördesigner försummas ofta pull-up-motstånd, vilket förenklar anslutningsschemat.

Det bör noteras att när kortet är anslutet via SPI är kortet mycket krävande på matningsspänningen och ett litet fall i matningsspänningen leder till att kortet inte fungerar, detta har verifierats av personlig erfarenhet, det finns inget att säga om SD-gränssnitt, jag har inte provat det än. Allt detta skrevs till för strömförsörjning är det nödvändigt att installera kondensatorer. När det gäller induktorn måste den vara klassad för ström upp till 100mA, men det är inte nödvändigt att installera den.

Diagrammen som visas ovan visar att kortet behöver 3,3 volt för att fungera, respektive i dataledningarna, spänningen bör inte gå över intervallet 0 - 3,3 volt, och här uppstår frågan, vad händer om MC:n drivs med 5 volt ?
Svaret är enkelt, du måste matcha datalinjerna, och detta kan göras med en konventionell resistiv avdelare.

Diagrammet visar att MISO-linjen inte behöver matchas eftersom data sänds över denna linje från kort till MK.
Faktum är att få människor ansluter kortet direkt till MK, det är mycket bekvämare att ansluta en kortkontakt till MK eller köpa en sköld med en kontakt och all nödvändig sele.

Vi kom på sambandet, låt oss nu titta på hur man använder biblioteket Petit FatFs, som är designad för 8-bitars mikrokontroller med liten minnesstorlek.

Biblioteket består av 5 filer:
heltal.h- en rubrikfil som beskriver huvuddatatyperna.

diskio.h- en rubrikfil som deklarerar prototyperna för lågnivåfunktioner för att arbeta med disken och statuskoderna de returnerar.

diskio.c- Lågnivåfunktioner bör implementeras i den här filen, initialt finns det "stubbar".

pffconf.h- konfigurationsfil.

pff.h- header-fil där prototyper av funktioner för interaktion med diskfilsystemet deklareras.

pff.c- filen innehåller implementeringar av funktioner för att interagera med diskfilsystemet.

Det kan ses att för att biblioteket ska fungera är det nödvändigt att implementera lågnivåfunktioner. Men om vi pratar om AVR eller PIC, för dem på webbplatsen kan du ladda ner ett exempel på att arbeta med biblioteket, som innehåller filen mmc, lågnivåfunktioner är redan implementerade i den. Det är också nödvändigt att ställa in bibliotekskonfigurationen i pff.h-filen och skriva de funktioner som krävs för att SPI ska fungera.

Funktioner hos Petit FatFs.

FRESULT pf_mount (FATFS*)- funktionen monterar/demonterar disken. Denna funktion måste anropas innan du börjar arbeta med disken, om du anropar funktionen med en nollpekare är disken avmonterad. Funktionen kan anropas när som helst.

alternativ
FATFS* fs- en pekare till ett objekt av typen FATFS, en beskrivning av denna struktur finns i filen pff.h. Vi behöver bara deklarera en variabel av denna typ.

Returvärden:
FR_OK (0)
FR_NOT_READY- enheten kunde inte initieras
FR_DISK_ERR- ett fel uppstod vid läsning från disk
FR_NO_FILESYSTEM- enheten har inte en giltig FAT-partition

FATFS fs;//Deklarera ett objekt av typen FATFS //Montera disken if (pf_mount(&fs) == FR_OK) ( //Disken är monterad, arbetar med den //Demontera disken pf_mount(NULL); ) else ( //Det gick inte att montera disken)

FRESULT pf_open (konst char* sökväg)- funktionen öppnar en befintlig fil. Efter att filen har öppnats kan du arbeta med den, det vill säga läsa från den och skriva till den. Du kan arbeta med en öppen fil tills en annan fil öppnas. Funktionen kan anropas när som helst.

alternativ
const char* väg- en pekare till en sträng som anger sökvägen till filen. Sökvägen måste specificeras helt i förhållande till rotkatalogen, separera katalogerna med ett snedstreck.

Returvärden:
FR_OK (0)- returneras i händelse av framgångsrikt genomförande av funktionen
FR_NO_FILE- Filen hittades inte
FR_DISK_ERR- diskfel
FR_NOT_ENABLED- disken har inte monterats

FATFS fs;//deklarera ett objekt av FATFS-typ //montering av disken if (pf_mount(&fs) == FR_OK) ( //öppnar filen som finns i rotkatalogen if(pf_open("hello.txt") == FR_OK ) ( //doing something ) //öppna filen som finns i mappen new if(pf_open("new/hello.txt") == FR_OK) ( //do something ) //demontera disken pf_mount(NULL); ) else ( // misslyckades med att montera disk)

FRESULT pf_read(void* buff, WORD btr, WORD* br)- funktionen läser det angivna antalet byte från filen och sparar dem i bufferten. Om antalet lästa byte är mindre än vad som anges, har slutet av filen nåtts.
#define _USE_READ 1

Alternativ:
void*buff- pekare till bufferten i vilken den lästa datan är lagrad
ORD btr- antal byte som ska läsas
ORD*br- en pekare till en variabel som lagrar antalet lästa byte.

Returvärden:
FR_OK (0)- returneras i händelse av framgångsrikt genomförande av funktionen
FR_DISK_ERR- diskfel
FR_NOT_OPENED- filen öppnades inte
FR_NOT_ENABLED- disken har inte monterats

FATFS fs;//deklarera ett objekt av typen FATFS BYTE buff;//buffert för att läsa en fil WORD br; // räknare av byte läst // montera disken if (pf_mount(&fs) == FR_OK) ( // öppna filen som finns i rotkatalogen if(pf_open("hej.txt") == FR_OK) ( // read 10 byte från det pf_read(buff, 10, &br); if(br != 10) ( //om br inte är lika med 10 //det betyder att vi har nått slutet av filen ) ) )

FRESULT pf_write(const void* buff, WORD btw, WORD* bw)- funktionen låter dig skriva data till en öppen fil. För att funktionen ska fungera i filen pffconf.h måste du skriva
#define _USE_WRITE 1

Alternativ:
void*buff- pekare till bufferten vi vill skriva, nollvärde avslutar skrivningen
WORD btw- antalet byte vi vill skriva
ORD*bw- en pekare till en variabel som lagrar antalet byte som kan skrivas. Genom att analysera denna variabel kan du ta reda på om slutet av filen har nåtts.

Returvärden:
FR_OK (0)- returneras i händelse av framgångsrikt genomförande av funktionen
FR_DISK_ERR- diskfel
FR_NOT_OPENED- filen öppnades inte
FR_NOT_ENABLED- disken har inte monterats

På grund av det faktum att biblioteket är designat för mikrokontroller med en liten mängd minne, har denna funktion ett antal begränsningar:

• du kan inte skapa nya filer, och du kan bara skriva till befintliga
• filstorleken kan inte ökas
• kan inte uppdatera tidsstämpeln
• en skrivoperation kan endast startas/stoppas vid en sektorgräns
• skrivskyddat filattribut kan inte förhindra skrivning

För att förstå den näst sista punkten måste du veta att kortets minne är uppdelat i block (sektorer) på 512 byte och inspelning kan endast startas från början av sektorn. Således, om vi vill skriva 1000 byte, kommer den första sektorn att skrivas fullständigt, och endast 488 byte kommer att skrivas till den andra, och de återstående 24 byte kommer att fyllas med nollor.

För att skriva till en öppen fil, gör följande:

• ställ in pekaren till sektorgränsen, om den inte är inställd på gränsen kommer pekaren att avrundas till den nedre sektorgränsen
• anropa skrivfunktionen önskat antal gånger
• avsluta posten genom att anropa funktionen med en nollpekare

För att ge ett exempel på hur inspelningsfunktionen fungerar är det nödvändigt att överväga ytterligare en funktion.

FRESULT pf_lseek(DWORD offset)- ställer in läs/skrivpekaren i den öppna filen. Du kan ställa in pekaren med en absolut eller relativ offset; för en absolut offset måste du skicka ett nummer till funktionen
pf_lseek(5000);
för relativ, skicka värdet på pekaren till den aktuella positionen fs.fptr och mängden förskjutning
pf_lseek(fs.fptr + 3000);
För att funktionen ska fungera i filen pffconf.h måste du skriva
#define _USE_LSEEK 1

Alternativ:
DWORD offsetär antalet byte att flytta pekaren till.

Returvärden:
FR_OK (0)- returneras i händelse av framgångsrikt genomförande av funktionen
FR_DISK_ERR- diskfel
FR_NOT_OPENED- filen öppnades inte

Du kan skriva data till en fil på följande sätt.
FATFS fs;//deklarera ett objekt av typen FATFS BYTE buff;//buffert för att läsa en fil WORD br; // räknare av byte läst // montera disken if (pf_mount(&fs) == FR_OK) ( // öppna filen som finns i rotkatalogen if(pf_open("hello.txt") == FR_OK) ( // set pekaren till den första sektorn pf_lseek(0); //write pf_write(buff, 10, &br); //slutför skrivningen pf_write(0, 0, &br); ) )

Jag lämnar också här en bit riktigt fungerande kod som använder alla funktioner som beskrivs ovan.
#define F_CPU 8000000UL #define buff_size 10 #include #omfatta #inkludera "diskio.h" #inkludera "pff.h" #inkludera "spi.h" FATFS fs;//deklarera ett objekt av typen FATFS BYTE read_buff;//buffer för att läsa filen BYTE write_buff = "hej ord"; /// /buffer för att skriva till filen UINT br; // räknare av byte read int main(void) ( // montera disken if (pf_mount(&fs) == FR_OK) ( // öppna filen i mappen new if(pf_open("new/hello.txt") = = FR_OK) ( //set write pointer pf_lseek(0); //write pf_write(write_buff, buff_size, &br); //finalize write pf_write(0, 0, &br); //set read pointer pf_lseek(0); / /läs att vi skrev pf_read(read_buff, buff_size, &br); if(br != buff_size) ( //om br inte är lika med buff_size //det betyder att vi har nått slutet av filen ) ) //montera disk pf_mount(NULL); ) while(1) ( ) )

FRESULT pf_opendir(DIR* dp, const char * sökväg)- funktionen öppnar en befintlig katalog och skapar en pekare till ett objekt av typen DIR, som kommer att användas för att få en lista över filer i den öppna katalogen.
För att funktionen ska fungera i filen pffconf.h måste du skriva
#define _USE_DIR 1

Alternativ:
DIR *dp- pekare till en variabel av typen DIR.

const char * väg- pekare till en sträng som innehåller sökvägen till katalogen, kataloger separeras med ett snedstreck

Returvärden:
FR_OK (0)- returneras i händelse av framgångsrikt genomförande av funktionen
FR_NO_PATH- kunde inte hitta vägen
FR_NOT_READY- Det gick inte att initiera disken
FR_DISK_ERR- diskfel
FR_NOT_ENABLED- disken har inte monterats

//deklarera variabler FATFS fs; DIR dir; //montera disk pf_mount(&fs); //öppen katalog pf_opendir(&dir, "MIN_MAPP");

FRESULT pf_readdir(DIR* dp, FILINFO* fno)- funktionen låter dig läsa innehållet i katalogen. För att göra detta, öppna en katalog med funktionen pf_opendir() och anrop pf_readdir(). Varje gång funktionen anropas kommer den att returnera namnet på objektet (mapp/fil) som finns i den angivna katalogen. När den har gått igenom alla objekt kommer den att returnera nollsträngen i arrayelementet fno.fname.
För att funktionen ska fungera i filen pffconf.h måste du skriva
#define _USE_DIR 1

Alternativ:
DIR *dp- pekare till en variabel av typen DIR, som måste deklareras tidigare

FILINFO *fnr- en pekare till en variabel av typen FILINFO, som måste deklareras tidigare.

Returvärden:
FR_OK- framgångsrikt slutförande av funktionen
FR_DISK_ERR- diskfel
FR_NOT_OPENED- katalogen är inte öppen

FATFS fs; FRESULTAT res; FILINFO fno; DIR dir; //montera disk pf_mount(&fs); //öppen katalog res = pf_opendir(&dir, MY_FOLDER); //läs innehållet i katalogen för(;;)( res = pf_readdir(&dir, &fno); //kontrollera om det fanns några fel vid läsning av // och om det fortfarande finns filer i den angivna katalogen om ((res! = FR_OK) || ( fno.fname == 0))( break; ) //visa på ett bekvämt sätt fno.fname usart_sendStr(fno.name); usart_sendStr(/r); )

Och slutligen lämnar jag arbetsprojektet här

SD-kort är baserade på det äldre Multi Media Card-formatet (MMC), men de flesta är fysiskt något tjockare än MMC-kort. De har också högre dataöverföringshastigheter. DRM-funktioner är tillgängliga men används lite. SD-kort mäter i allmänhet 32 ​​mm × 24 mm × 2,1 mm, men kan vara så tunna som 1,4 mm, precis som MMC-kort.

Det finns olika hastighetsklasser tillgängliga. De hänvisas till med samma nx-notation som CD-ROM-skivor; en multipel på 150 kB/s. Enheter med SD-kortplatser kan använda de tunnare MMC-korten, men standard SD-kort passar inte in i de tunnare MMC-kortplatserna. MiniSD- och MicroSD-kort kan användas direkt i SD-kortplatser med en adapter. Det finns läsare som gör att SD-kort kan nås via många anslutningsportar som USB, FireWire.

Stift	SD-läge			SPI-läge
	namn	typ	Beskrivning	namn	typ	Beskrivning
1	CD/DAT3	I/O/PP	Kortdetektering / Kontaktdatalinje 3	CS	jag	Markval i låg status
2	cmd	PP	kommando/svarsrad	DI	jag	dataingång
3	Vss1	S	GND	VSS	S	GND
4	vdd	S	strömförsörjning	VDD	S	strömförsörjning
5	CLK	jag	Klocka	SCLK	jag	Klocka
6	Vss2	S	GND	VSS2	S	GND
7	DAT0	I/O/PP	kontaktdatalinje 0	DO	O/PP	datautgång
8	DAT1	I/O/PP	kontaktdatalinje 1	RSV
9	DAT2	I/O/PP	kontaktdatalinje 2	RSV

SD-korts gränssnitt är kompatibelt med standard MMC-kortfunktioner. Alla SD-minnen och SDIO-kort krävs för att stödja det äldre SPI/MMC-läget som stöder det lite långsammare fyrtrådiga seriella gränssnittet (klocka, seriell in, seriell ut, chipval) som är kompatibel med SPI-portar på många mikrokontroller. Många digitalkameror, digitala ljudspelare och andra bärbara enheter använder förmodligen endast MMC-läge. MMC-läget ger inte åtkomst till de proprietära krypteringsfunktionerna på SD-kort, och den kostnadsfria SD-dokumentationen beskriver inte dessa funktioner. Eftersom SD-krypteringen främst finns för medieproducenter, är den inte till stor nytta för konsumenter som vanligtvis använder SD-kort för att hålla oskyddad data.

Det finns tre överföringslägen som stöds av SD: SPI-läge (separat seriell in och seriell ut), en-bits SD-läge (separata kommando- och datakanaler och ett proprietärt överföringsformat) och fyra-bitars SD-läge (använder extra stift plus några omtilldelade stift) för att stödja fyra bitars breda parallella överföringar. Låghastighetskort stöder 0 till 400 kbit/s datahastighet och SPI- och enbits SD-överföringslägen. Höghastighetskort stöder 0 till 100 Mbit/s datahastighet i fyrabitarsläge och 0?25 Mbit/s i SPI- och enbits SD-lägen.

SD-korts säkerhetsfunktioner inkluderar:

• Upphovsrättsskyddsmekanism med SDMI-standarden (Secure Digital Music Initiative)
• Integrerat CPRM-filskydd och krypteringssystem (CPRM är ett innehållsskydd för inspelningsbara media)

För några år sedan i maj 2011 presenterade skaparen av kultspelet Elite, David Breben, det första konceptet av en Raspberry Pi enkortsdator. Det här ögonblicket blev en vändpunkt i mitt liv. Tanken på att göra en dator lika stor som en flashenhet låg på ytan, men den tog fart bara med hjälp av Raspberry Pi Foundation.

Redan den 25 juli 2011 sätts alfaversionen av datorn i produktion. Tyvärr har konceptet för projektet förändrats, och nu är det placerat som en dator på storleken av ett kreditkort. Trots denna omständighet följde miljontals människor honom. Jag lydde också effekten av publiken och kollade dagligen på projektets officiella sida. En lång och smärtsam väntan började på "miraklet" som hände den 29 februari 2012 - försäljningsstarten.

Raspberry Pi kan köpas via Farnell-nätverket eller från RS Components. Som det visade sig, den 29 februari, kunde endast förbeställningar göras. Inget av kontoren hade dessa tavlor i lager. Den första satsen enheter var bara 10 000 exemplar, så med tanke på spänningen kring projektet var det mycket svårt att göra en beställning. Men efter att ha övervunnit alla svårigheter, klockan 14:06 samma dag, köptes datorn för £46,73 från Farnell.

Ingen av mina utländska order har uppfyllts under så lång tid. Jag blev extremt upprörd över att Farnell, som tog 20 pund för leverans, skickade paketet den 29 maj 2012 (2 månader senare) med vanlig post utan spårningsnummer. Överraskande nog levererade symbiosen mellan den kungliga och ryska posten paketet säkert och väl redan den 22 juni. Det var det mest önskade paketet de senaste månaderna, så eftersom jag inte kunde stå emot stressen var jag tvungen att ta ledigt från jobbet och springa till posten.

Det är ingen mening att prata om hur man ställer in Raspberry Pi för första körningen. Med en artikel om detta ämne var jag ett par år sen, många rader om detta har redan skrivits på andra resurser, och på Youtube tillräckligt många videor har lagts upp. Men jag vill prata om ett betydande fel i designen för mig - den obekväma platsen för SD-kortplatsen. När kortet sätts i sticker det kraftigt ut utanför brädet, vilket förstör utseendet på ett hemmagjort fodral.

Det finns två alternativ för att lösa detta problem: löd SD-> microSD-adaptern parallellt med kontakten installerad på Raspberry Pi (du kan läsa hur du gör detta i en artikel om Habré), eller använd Low-profile MicroSD-> SD-adapter. Det första alternativet är helt enkelt oacceptabelt för mig - ja, handen stiger inte för att löda brädan, eftersom. Jag är rädd för att förstöra presentationen av min Malinka. Jag tror att det bästa valet är att använda en lågprofiladapter.

Inledningsvis beslutades det att köpa en sådan adapter i en av de utländska nätbutikerna. Det finns ett val, men kostnaden för sådana prydnadssaker är helt enkelt oöverkomlig. De billigaste kostar $10, och några av dem ser ärligt talat hemgjorda ut. Det slutliga beslutet att göra adaptern själv togs efter att ha besökt DIYGadget-webbplatsen, var uppmärksam på hur lätt det är att upprepa deras skapelse.

Redo? Låt oss gå från ord till handling. För att göra adaptern korrekt, låt oss studera specifikationen för SD- och microSD-kort. Allt som är nödvändigt för tillverkning försökte jag systematisera i tabell 1, 2.

Tabell 2: Pinout av SD-minneskort

Genom att ansluta motsvarande kontakter på minneskorten, och genom att kombinera Vss1, Vss2, får vi det elektriska kretsschemat för adaptern.

För att göra en adapter behöver vi:
1) Hållare för microSD (CF TFC-WPCE-08 MICROSD CARD) - 52,22 rubel.
2) En bit dubbelsidig folieglasfiber med en yta på cirka 4 cm 2 (2% av positionen STEKLOTEKSTOLIT FOIL GIR.1.5MM 2 SIDOR) - 3 rubel.
3) Material för installation (järnklorid, tenn, flussmedel) - 10 rubel.

Då kommer kostnaden för projektet att vara 65 rubel 22 kopek och en viss mängd ledig tid. För att minska byggkostnaderna kan du byta ut microSD-korthållaren mot ett CF TFC-WPCER-08 MICROSD-KORT. Tyvärr var denna artikel inte tillgänglig på CJSC Promelectronicas lager, så jag köpte ett dyrare alternativ. Jag uppmärksammar dig på att om du ändrar typ av hållare så kanske du inte kan använda min mall för LUT (laser-strykningsteknik).

För PCB-design använde jag Autocad, eftersom min favorit SprintLayout kunde inte behaga närvaron av den önskade mallen. För dem som gillar att modifiera det tryckta kretskortet kan du ladda ner källan i DWG-format, och om det inte finns något sådant behov, sedan ett tomt i PDF-format (jag rekommenderar att du kontrollerar måtten innan du applicerar mallen från PDF).

Efter att mallen har överförts till brädan rekommenderar jag att borra hål med en diameter på 0,5 mm för att gå från ett lager till ett annat.

Jag gör övergången från lager till lager med en tunn tråd, efter att tidigare ha förtenat spåren på den framtida adaptern. På de ställen där hålen är under microSD-hållaren är det nödvändigt att slipa bort droppar av tenn med en nålfil så att den installeras utan förvrängning. Till sist monterar vi hållaren. Om olika flussmedel användes under tillverkningsprocessen av brädan, se till att spola brädet innan du trycker in det i din Raspberry Pi.

Gör adaptern själv eller köp - du väljer. För att göra valet mer informerat, speciellt för dig, har jag valt flera länkar för köp:
1) Raspberry Pi Premium Low-profile MicroSD (TF) till SD-kortadapter. Skydda brädan.
2) Raspberry Pi Lågprofil MicroSD till SD-kortadapter, SD-kort kommer inte att skadas!!
3) MicroSD till "kort" SD / RS-MMC-adapter. För Everdrive-vagnar, Raspberry Pi, etc.
4) Lågprofil MicroSD till SD-kortadapter för Raspberry Pi.
5) SD-kortadapter för Raspberry pi REV2 + fri frakt.

Avslutningsvis skulle jag vilja säga att allt material endast är avsett för informationsändamål. Användning av utvecklingar för kommersiella ändamål är strängt förbjudet. Återtryck av material är endast möjligt med mitt tillstånd och med förbehåll för hänvisningar till källan. De som vill stödja inte bara i ord, utan också i handling, samt tack - vänligen kontakta mig via mail.

För att montera enheten själv måste du ladda ner följande filer:
1. Källkort för LUT i DWG-format
2. Avgift för LUT i PDF-format

Lycka till i dina ansträngningar!!!

Så länge jag kan minnas har jag alltid älskat att läsa, men på 2000-talets gård, och ibland kan den nödvändiga litteraturen bara hittas på Internet. Ja, och du kan läsa e-böcker på en elektronisk enhet som en surfplatta, dator eller läsare. Resultatet är en liten enhet som kan läsa textfiler från ett SD- eller microSD-kort och visa deras innehåll på skärmen.

Hjärnan i enheten är en Atmega32 mikrokontroller som arbetar med en frekvens på 8 MHz. MK är klockad från en extern kvarts på 8 MHz; som en enhetsskärm använde jag en liten LCD-indikator WH1604A på HD44780-kontrollern med en upplösning på 4 rader med 16 tecken vardera. Knapparna använde den vanliga klockan, som för SD-kortet för att ansluta den till mikrokontrollern, använde jag motståndsdelare för att matcha logiknivåerna.

Schematiskt diagram av enheten:

I diagrammet är pinouten endast korrekt för SD-kortet eller SD-adaptern, använd deras pinout för att ansluta andra kort!

Enheten stöder SD-, miniSD- och microSD-minneskort upp till 4GB formaterade i FAT, FAT16 filsystem. Man bör komma ihåg att enheten inte stöder kataloger, så alla filer måste endast skrivas till roten på flashenheten. Textfiler måste vara i det vanliga txt-formatet och utan formatering, filnamn får inte vara längre än 8 tecken (exklusive tillägget).

När enheten är påslagen kommer startskärmen att visas på displayen:

Om SD-kortet inte är installerat i enheten, inte är korrekt anslutet eller något annat, visas följande meddelande:

Om allt är i sin ordning kommer huvudmenyn att visas:

Med hjälp av knapparna kan du gå in i "Bläddra bland filer", där du kan välja den fil du behöver läsa.

I alternativet "Inställningar" kan du välja med vilket filtillägg som ska visas i "Bläddra bland filer".

Och i det sista stycket "Om systemet ..." kan du läsa information om enheten, dess författare, etc.

Jag skrev firmware för enheten i BASCOM-AVR-miljön med hjälp av AVRDOS-biblioteket, firmwaren tar bara upp 30% av mikrokontrollerns programminne, så det finns utrymme för kreativitet. Inuti är enheten monterad på två tryckta kretskort: på den ena finns en MK med ett bodykit, på den andra finns en kontakt för ett SD-kort och matchande kedjor av logiska nivåer.

Här är ett foto av enheten inuti:

För ström använde jag ett 4,8V, 600mAh Ni-Cd-batteri. Efter att ha blinkat mikrokontrollern måste du installera följande säkringsbitar:

Lista över radioelement

Beteckning	Typ	Valör	Kvantitet	Notera	Göra	Mitt anteckningsblock
U1	MK AVR 8-bitars	ATmega32	1			Till anteckningsblock
Dl, D2	likriktardiod	1N4001	2			Till anteckningsblock
Cl, C2	Kondensator	22 pF	2			Till anteckningsblock
C3	Elektrolytkondensator	100uF	1			Till anteckningsblock
C4	Kondensator	100 nF	1			Till anteckningsblock
R1	Motstånd	10 kOhm	1			Till anteckningsblock
R2-R4	Motstånd	4,7 kOhm	3			Till anteckningsblock
R5-R7	Motstånd	1 kOhm	3			Till anteckningsblock
LCD1	LCD skärm	LM014L	1			Till anteckningsblock
X1	Kvarts	8 MHz	1			Till anteckningsblock
	Knapp		4			Till anteckningsblock
	Växla		1