Académique Documents
Professionnel Documents
Culture Documents
Contenido
Convenciones utilizadas en este
documento................................. .................................... 6
Observaciones generales (aplicables a sistema de archivos FAT Todo
Tipo)............. ........ 6
Boot Sector y BPB
..6
Estructura de los datos del FAT .
12
FAT Tipo
.13
Inicializacin de volmenes FAT.......
.18
FAT32 fsinfo Estructura Sectorial y el sector de inicio de copia de
seguridad................. 20
FAT Estructura de
directorios
.21
Otras notas relativas a los directorios
FAT...................................................................... 24
Especificacin
..25
Microsoft, MS_DOS, Windows y Windows NT son marcas comerciales o marcas
comerciales registradas de Microsoft Corporation en los Estados Unidos
y / u otros pases. Otros nombres de productos y compaas aqu mencionados
pueden ser marcas comerciales de sus respectivos propietarios.
1999 Microsoft Corporation. Todos los derechos reservados.
Renuncia
IMPORTANTE-LEA DETENIDAMENTE: Este acuerdo de Microsoft ("Acuerdo") es un legal acuerdo entre
usted (sea persona fsica o jurdica) y Microsoft Corporation ("Microsoft") para esta versin de la
especificacin de Microsoft identificado anteriormente ("Especificaciones").
AL DESCARGAR, COPIAR O UTILIZAR LAS ESPECIFICACIONES, USTED ACEPTA LOS TRMINOS DE
ESTE ACUERDO. SI NO ESTOY DE ACUERDO CON LOS TRMINOS DE ESTE ACUERDO, NO
DESCARGUE, COPIAR, O UTILIZAR LA ESPECIFICACIN.
La especificacin es propiedad de Microsoft o sus proveedores y est protegido por leyes de propiedad
intelectual internacionales y los tratados de derechos de autor, as como otras leyes de propiedad intelectual
y los tratados.
1. PACTO LIMITED no demandar.
(A) Siempre y cuando cumpla con todos los trminos y condiciones de este Acuerdo y sujeto a las
limitaciones en Secciones 1 (b) - (e) siguiente, Microsoft le concede la siguiente licencia no exclusiva,
mundial, libre de regalas, no transferible, no sublicenciable pacto limitado, recproca no demandar:
(I) Een virtud de los derechos de autor son propiedad o licenciable por Microsoft sin el pago de
atencin a terceros no afiliados, para reproducir el Pliego nicamente con la finalidad de crear partes
de los productos que se ajusten a la especificacin en forma no modificada, y
(Ii) En el marco de sus reclamos necesarios nicamente para fabricar, hacer fabricar, usar, importar
y directa e indirectamente, ofrecer en venta, vender y distribuir de otra manera y disponer de partes
de productos que cumplan la especificacin en forma no modificada.
Para efectos de lo anterior, la especificacin es "sin modificaciones", si no hay cambios, adiciones o
extensiones de la especificacin y "Reclamaciones necesario" significa pretensiones de una solicitud de
patente o patente que son: (1) propiedad o licenseable por Microsoft sin pago de una contraprestacin a un
tercero no afiliado parte, y (2) tienen una fecha de presentacin efectiva antes del 31 de diciembre de 2010,
que debe ser infringido el fin para que una parte (s) de un producto que cumpla con la especificacin.
Reclamaciones necesarios no incluye las reclamaciones relativas a la tecnologa de fabricacin de
semiconductores o circuitos de microprocesador o no reclamaciones requiere que se infrinja en el
cumplimiento del pliego de condiciones (aunque en la misma patente como necesaria Reclamos).
(B) El pacto anterior no demandar no se extender a cualquier parte o funcin de un producto que (i) no es
obligado a cumplir con la especificacin en forma no modificada, o (ii) a la que haba una manera
comercialmente razonable alternativa a infringir una demanda necesaria.
(C) El pacto de no demandar descrito anteriormente deber estar disponible para usted y se dar por
terminado de inmediato si Usted o alguno de sus afiliados (colectivamente "Partes covenantee") "inicia" una
accin por infraccin de patente contra: (X) Microsoft o cualquiera de sus filiales (colectivamente "Concesin
Party"), (y) los clientes o distribuidores de la concesin Partes, u otros destinatarios de un pacto de no
demandar con respecto a la especificacin de la Parte que otorga ("Covenantees"), o (z) los clientes o
distribuidores de Covenantees (todas las partes identificadas en (y) y (z) colectivamente denominados
"Clientes"), que la accin se basa en una aplicacin conforme de la Especificaciones. Como se usa aqu,
"Afiliada" significa cualquier entidad que controla, directa o indirectamente, es controlada por, o
est bajo el control comn de una fiesta, y control: la energa, ya sea directo o indirecto, de dirigir o
hacer que el directo de la gestin o polticas de cualquier entidad ya sea a travs de la propiedad de los
valores de voto, por contrato o de otra manera. "Iniciados" significa que una Parte covenantee es la primera
(como las de la Parte que otorga y el Partido covenantee) para presentar o instituir cualquier reclamacin o
accin legal o administrativa por violacin de patentes contra el Partido concesin o cualquiera de los
clientes. "Iniciados" incluye cualquier situacin en la que una Parte covenantee archivos o inicia una
reclamacin o accin legal o administrativa por violacin de patentes nicamente como una reconvencin o
equivalente en respuesta a una Parte que autoriza la primera presentacin o instituir una infraccin de
patente legal o administrativa reclamacin contra dicha Parte covenantee.
(D) El pacto de no demandar descrito anteriormente no se extiende al uso de cualquier parte de la
especificacin para ningn propsito que no sea (a) para crear partes de un sistema operativo (i) slo cuando
sea necesario para adaptar tales sistema operativo para que pueda interactuar directamente con una
aplicacin de firmware del firmware extensible Iniciativa Especificacin v 1.0 ("Especificacin EFI"), (ii) slo
cuando sea necesario para emular una implementacin de la EFI Especificacin, y (b) para crear el firmware,
aplicaciones, utilidades y / o controladores que se utilizarn y / o autorizados para el slo los siguientes
propsitos:
(i) para instalar, reparar y mantener el hardware, firmware y partes de funcionamiento
Software del sistema que se utiliza en el proceso de arranque,
(ii) para proporcionar a una empresa de servicios de tiempo de ejecucin del sistema operativo que
se especifican en el Pliego de EFI,
(iii) Para diagnosticar y corregir fallas en el hardware, firmware o de funcionamiento
software del sistema; (iv) para la consulta para la identificacin de un sistema informtico (ya sea
por nmeros de serie, etiquetas de activos, el usuario o de otra manera);
(v) para realizar el inventario de un sistema informtico, y
(vi) para fabricar, instalar y configurar cualquier
hardware, firmware o software del sistema operativo.
(e) Microsoft se reserva todos los dems derechos que pueda tener en la memoria y la propiedad intelectual
en el mismo. La posesin de este documento no le otorga ninguna pacto de no demandar con respecto a
cualquier
otras patentes de Microsoft, marcas registradas, derechos de autor u otros derechos de propiedad intelectual,
o cualquier licencia con
respeto a los derechos de propiedad intelectual de Microsoft.
2. LIMITACIONES ADICIONALES Y OBLIGACIONES.
(A) El pacto anterior no demandar slo es aplicable a la versin de la especificacin de que usted es a punto
de descargar. No se aplica a las versiones adicionales de o ampliaciones de la especificacin. (B) Sin perjuicio
de cualquier otro derecho, Microsoft podr terminar el presente Acuerdo, si usted no cumple con el trminos
y condiciones de este Acuerdo. En tal caso, deber destruir todas las copias del Pliego.
3. DERECHOS DE PROPIEDAD INTELECTUAL. Todos propiedad, titularidad y derechos de propiedad
intelectual en y para la
Especificacin son propiedad de Microsoft o sus proveedores.
4.U.S. DERECHOS DEL GOBIERNO. Cualquier especificacin suministrado al Gobierno de EE.UU. en
respuesta a solicitudes
emitido el o despus del 1 de diciembre de 1995 se proporciona con los derechos comerciales y las
restricciones descritas en
en este documento. Cualquier especificacin suministrado al Gobierno de EE.UU. en respuesta a solicitudes
emitidas antes del 1 de diciembre de 1995 se proporciona con DERECHOS LIMITADOS previstos en FAR, 48
CFR 52.227-14 (junio de 1987) o DFAR,
48 CFR 252.227-7013 (OCTUBRE 1988), segn sea el caso. RESTRICCIONES
5.RESTRIXIONES DE EXPORTACION. La exportacin de la especificacin, cualquier parte del mismo, o
cualquier proceso o servicio que sea el producto directo de la Especificacin (lo anterior se hace referencia
colectivamente como el "restringido Componentes ") de los Estados Unidos se rige por el Reglamento de
Administracin de Exportaciones (EAR, 15 CFR 730 a 744) del Departamento de Comercio de EE.UU., la
Oficina de Administracin de Exportaciones ("BXA"). Usted se compromete a cumplir con la EAR en la
exportacin o reexportacin de los Componentes restringidos (i) a cualquier pas al que los EE.UU. haya
embargado o restringido la exportacin de bienes o servicios, que incluyen en la actualidad, pero no son
necesariamente limitado a Cuba, Irn, Irak, Libia, Corea del Norte, Sudn, Siria y la Repblica Federal de
Yugoslavia (Serbia incluyendo, pero no Montenegro), oa cualquier ciudadano de cualquier pas, siempre que
sea , que intente transmitir o transportar los Componentes restringidos de nuevo a ese pas, (ii) a cualquier
persona o entidad que usted sabe o tiene razones para sospechar que utilizar los Componentes restringidos
en el diseo, desarrollo o produccin de armas nucleares, qumicas o biolgicas, o (iii) a cualquier persona o
entidad que se ha prohibido participar en transacciones de exportacin de Estados Unidos por cualquier
agencia federal del Gobierno de los EE.UU.. Usted garantiza y representa que ni la BXA ni ninguna otra
agencia federal de EE.UU. tiene suspendido, revocado o denegado sus privilegios de exportacin. Para
obtener informacin adicional, consulte http://www.microsoft.com/exporting.
6. RENUNCIA DE GARANTAS. En la medida mxima permitida por la ley aplicable, Microsoft y sus
proveedores ofrecen el pliego de condiciones (y toda la propiedad intelectual en el mismo) y (en
su caso) servicios de apoyo relacionados con el pliego de condiciones ("Servicios de Asistencia")
TAL CUAL Y CON TODOS SUS DEFECTOS, y por la presente negamos cualquier garanta o
condicin, ya sea expresa, implcita o estatutaria, incluida, pero no limitado a, cualquier (si los
hay) garantas o condiciones implcitas de comerciabilidad, de aptitud para un propsito en
particular, de la ausencia de virus, de la exactitud o integridad de respuestas, resultados, y de
falta de negligencia o falta de esfuerzo razonable, todo lo que se refiere a la especificacin,
cualquier la propiedad intelectual en el mismo y la prestacin o no de proporcionar servicios de
apoyo. TAMBIN, NO EXISTE GARANTA O CONDICIN DE TTULO, DISFRUTE Y POSESIN
PACFICOS, CORRESPONDENCIA CON LA DESCRIPCIN O NO INFRACCIN, CON RESPECTO A LA
ESPECIFICACIONES Y CUALQUIER PROPIEDAD INTELECTUAL EN EL MISMO. EL RIESGO EN CUANTO
A LA CALIDAD DE O DERIVADOS DEL USO O LA EJECUCIN DEL PLIEGO DE CONDICIONES,
CUALQUIER PROPIEDAD INTELECTUAL EN EL MISMO, Y SERVICIOS DE APOYO, EN SU CASO, se
queda con ustedes.
7. EXCLUSIN DE DAOS INCIDENTALES, CONSECUENCIALES Y OTROS DAOS. AL MEDIDA
MXIMA PERMITIDA POR LAS LEYES APLICABLES, EN NINGN CASO MICROSOFT O SUS
PROVEEDORES SERN RESPONSABLES POR NINGN DAO ESPECIAL, INCIDENTAL, INDIRECTO O
CONSECUENTE DAO (INCLUYENDO, PERO NO LIMITADO A, DAOS POR PRDIDA DE BENEFICIOS
O DE INFORMACIN CONFIDENCIAL O DE OTRO TIPO, INTERRUPCIN DE LA ACTIVIDAD
COMERCIAL, LESIONES PERSONALES, PRDIDA DE PRIVACIDAD, POR INCUMPLIMIENTO DE
OBLIGACIONES, YA SEA DE BUENA FE O CUIDADO RAZONABLE, NEGLIGENCIA Y POR CUALQUIER
OTRA PECUNIARIA O DE ALGUNA OTRA PRDIDA) DERIVADOS O DE ALGUNA MANERA
RELACIONADOS CON EL USO O LA IMPOSIBILIDAD DE USO DEL PLIEGO DE CONDICIONES,
CUALQUIER PROPIEDAD INTELECTUAL ELLOS, LA PROVISIN O FALLA EN LA PROVISIN DE
SERVICIOS DE SOPORTE U OTRO BAJO O EN RELACIN CON CUALQUIER DISPOSICIN DE ESTE
ACUERDO, AUN EN EL CASO DE FALLA, AGRAVIO (INCLUYENDO NEGLIGENCIA), RESPONSABILIDAD
ESTRICTA, INCUMPLIMIENTO DE CONTRATO O VIOLACIN DE LA GARANTA DE MICROSOFT O
CUALQUIER PROVEEDOR INCLUSO SI MICROSOFT O CUALQUIER PROVEEDOR HA SIDO ADVERTIDO
DE LA POSIBILIDAD DE TALES DAOS.
8. LIMITACIN DE RESPONSABILIDAD Y RECURSOS. Sin perjuicio de cualquier dao que pudiera
incurrir por cualquier motivo (incluyendo, sin limitacin, todos los daos mencionados
anteriormente y todos los directos o daos generales), la responsabilidad total de Microsoft y
cualquiera de sus proveedores bajo cualquier disposicin de este Acuerdo y el nico recurso para
todo lo anterior se limitarn a la mayordel importe abonado por usted para la especificacin o
EE.UU. $ 5.00. Las limitaciones anteriores,
exclusiones y limitaciones de responsabilidad se aplicarn en la medida mxima permitida por la
ley aplicable, incluso si
cualquier recurso no cumple su propsito esencial.
9. LEY APLICABLE. Si ha adquirido este Pliego en los Estados Unidos, este acuerdo se rige por la
leyes del Estado de Washington. Si ha adquirido este Pliego en Canad, a menos que
expresamente prohibida por las autoridades locales ley, este acuerdo est gobernado por las
leyes vigentes en la Provincia de Ontario, Canad, y, con respecto a cualquier controversia que
pueda surgir acerca del mismo, se somete a la jurisdiccin de los tribunales federales y
provinciales que se sientan en Toronto, Ontario. Si esta especificacin fue adquirido fuera de los
Estados Unidos, sern de aplicacin las leyes locales.
10.QUESTIONS. Si tiene alguna pregunta relacionada con este Acuerdo, o si desea ponerse en
contacto Microsoft por cualquier razn, por favor pngase en contacto con la subsidiaria de
Microsoft que atiende a su pas o escriba a: Microsoft Sales Information Center / One Microsoft
Way / Redmond, WA 98052-6399.
11.ACUERDO ENTIRE. Este Acuerdo es el acuerdo completo entre usted y Microsoft en relacin
con las Especificaciones y los servicios de soporte (si existe) y se sustituyen todos los anteriores
o contemporneas orales o las comunicaciones, propuestas y representaciones con respecto a la
especificacin o cualquier otro tema cubierto por este Acuerdo. En la medida en los trminos de
las polticas de Microsoft o programas para el conflicto de Servicios de Apoyo con los trminos
de este Acuerdo, los trminos de este Acuerdo controlar. Si vous avez acervo votre produit
Microsoft au CANADA, la garantie limite suivante vous preo: Renonciation Garantas AUX. Dans
toute la mesure permise par la lgislation en vigueur, Microsoft et ses fournisseurs fournissent
la Especificacin (ET A toute Propiedad Intelectual dans celle-ci) et tous (Selon le cas) les
servicios d'asistencia lis la especificacin ("Services d'assistance") Tels Quels ET AVEC TOUS
leurs dfauts, et par les presentes excluent toute garantie ou condicin expresse ou implicite,
lgale ou conventionnelle, crite ou verbal, y compris, mais sans limitacin, toute (selon le cas)
garantie ou ou condiciones implicite lgale de qualit marchande, de conformit un uso
particulier, d'ausencia de virus, d'exactitude et d'intgralit des rponses, de rsultats,
d'esfuerzos tcnicas et professionnels et d'ausencia de negligencia, le tout relativement a la
especificacin, toute proprit dans Intelectual celle-ci et la prestation ou la no prestation
des Services d'asistencia. DE PLUS, IL
N'Y A AUCUNE GARANTIE ET CONDICIN DE TTULO, DE goce PAISIBLE, DE POSESIN PAISIBLE, DE
SIMILARIT LA DESCRIPCIN ET D'AUSENCIA DE contrefaon relativement LA Especificacin
ET A Toute Propiedad Intelectual DANS Celle-CI. VOUS SUPPORTEZ TOUS LES RISQUES
DCOULANT ET DE L'UTILIZACIN DE LA EJECUCIN DE LA Especificacin ET DE TOUTE Propiedad
Intelectual DANS CELLE-CI ET ceux DCOULANT DES D'SERVICIOS DE ASISTENCIA (S'IL YA VEZ).
EXCLUSIN DES dommages INDIRECTOS, ACCESORIOS ET AUTRES. Dans toute la mesure permise
par la lgislation en vigueur, Microsoft et ses fournisseurs ne sont en aucun cas Responsables de
tout dommage especiales, indirectos, Accesorio, moral ou exemplaire quel qu'il soit (y compris,
mais sans limitacin, les dommages entrans par la perte de bnfices ou la perte d'information
confidentielle ou autre, l'interrupcin des affaires, les prejuicios corporels, la perte de
confidentialit, le dfaut de remplir toute obligacin y compris les obligaciones de bonne foi et
de diligencia raisonnable, la ngligence et toute autre perte pcuniaire ou autre perte de
quelque naturaleza Que ce soit) dcoulant de, ou de toute autre manire li , l'utilizacin ou
l'impossibilit d'utiliser la especificacin, toute Propiedad Intelectual dans celle-ci, la prestation
ou la no prestation des Services d'ou asistencia autrement en vertu de relativement ou toute
disposicin de cette convencin, Que ce soit en cas de faute, de dlit (y compris la negligencia),
de responsabilit stricte, de manquement un contrat de manquement ou une Garantie de
Microsoft ou de l'ONU de fournisseurs ses, et ce, meme SI Microsoft ou l'un de ses fournisseurs
un t Avise De La possibilit de tels dommages. LIMITACIN DE responsabilit ET recours.
Malgr tout dommage Que vous pourriez encourir vierta quelque razn Que ce soit (y compris,
mais sans limitacin, tous les dommages mentionns ci-dessus et tous les dommages dirige et
gnraux), la seule responsabilit de Microsoft et de ses fournisseurs en vertu de toute
disposicin de cette convencin et votre nica recours en relacin de tout ce qui sont preceden
Limites au plus lev des montants suivants: soit (a) le montant Que vous avez pay pour la
especificacin, soit (b) sin equivalant montant cinq dlares EE.UU. (5,00 dlares de los EE.UU.).
Les limitaciones, exclusiones et renonciations ci-dessus s'appliquent dans toute la mesure
permise par la lgislation en vigueur, et ce mme si leur aplicacin de un vertido effet de priver
sin recours de son esencia. Droits Limites DU GOUVERNEMENT Americain Tout Produit Logiciel
fourni au gouvernement amricain conformment des demandes mises le ou aprs le 1er
dcembre 1995 est offert avec les restricciones et droits commerciaux dcrits ailleurs dans la
presente convencin. Tout Produit Logiciel fourni au gouvernement amricain conformment
des demandes mises vanguardia le 1er dcembre 1995 est offert avec des droits Limites tels
Que prvus dans le FAR, 48CFR 52.227-14 (juin 1987) dans ou le FAR, 48CFR 252.227-7013
(octobre 1988), qu'applicables tels.
3 3 2 2 2 2 2 2
1 0 9 8 7 6 5 4
byte[2]
2 2 2 2 1 1 1 1
3 2 1 0 9 8 7 6
byte[1]
1 1 1 1 1 1 0 0
5 4 3 2 1 0 9 8
byte[0]
0 0 0 0 0 0 0 0
7 6 5 4 3 2 1 0
Esto es importante si su mquina es una mquina "big endian", ya que tendr que
traducir entre grande y pequeo endian al mover datos desde y hacia el disco.
Un volumen del sistema de archivos FAT se compone de cuatro regiones bsicas,
establecidas en la presente orden en el volumen:
0 Reserved Region
1 FAT Region
2 Root Directory Region (no existe en volmenes FAT32)
3 File and Directory Data Region (Archivo y Directorio de regin de datos)
BS_OEMName
BPB_BytsPerSec
11
BPB_SecPerClus
13
BPB_RsvdSecCn
t
14
BPB_NumFATs
16
BPB_RootEntCnt
17
BPB_TotSec16
19
BPB_Media
21
BPB_FATSz16
22
BPB_SecPerTrk
24
BPB_NumHeads
26
BPB_HiddSec
28
BPB_TotSec32
distinto
de
cero.
Para
volmenes FAT32, este campo debe ser 0.
Para FAT12 y Volmenes FAT16, este campo
contiene el nmero de sector y BPB_TotSec32
es 0 si el sector recuento total de "ajustes" (es
menor que 0x10000).
0xF8 es el valor estndar para (no extrable)
los medios de comunicacin "fijos". Para
medios extrables, se utiliza con frecuencia
0xF0. Los valores legales para este campo son
0xF0, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD,
0xFE y 0xFF. El nico otro punto importante es
que cualquier valor que se pone aqu tambin
se debe poner en el byte bajo del [0] entrada
FAT. Este se remonta a la antigua
determinacin de los medios de comunicacin
1.x de MS-DOS sealaron antes y ya no se
suele utilizar para cualquier cosa.
Este campo es el recuento de 16 bits
FAT12/FAT16 de sectores ocupados por ONE
FAT. En los volmenes FAT32 este campo debe
ser 0, y
BPB_FATSz32 contiene el recuento de tamao
de FAT.
Sectores por pista de 0x13 interrupcin. Este
campo slo es relevante para los medios de
comunicacin que tienen una geometra
(volumen se divide en pistas por mltiples
cabezas y cilindros) y son visibles en 0x13
interrupcin.
Este campo contiene los "sectores por pista"
valor geomtrico.
Nmero de cabezas de 0x13 interrupcin. Este
campo es relevante como se discuti
anteriormente para BPB_SecPerTrk. Este
campo contiene el uno base "recuento de
cabezas". Por ejemplo, en un 1,44 MB de 3,5
pulgadas conducir este valor es 2.
Cuenta de los sectores ocultos anteriores a la
particin que contiene este Volumen FAT. Este
campo es por lo general slo es relevante
para los medios de comunicacin visible en
0x13 interrupcin. Este campo debe ser
siempre cero en los medios de comunicacin
BPB_TotSec32
32
BS_Reserved1
37
BS_BootSig
38
BS_VolID
39
BS_VolLab
43
11
BS_FilSysType
54
Offse
t
(byte
)
tama
o
(byte
s)
Descripcin
BPB_FATSz32
36
BPB_ExtFlags
40
BPB_FSVer
42
BPB_RootClus
44
BPB_FSInfo
48
BPB_BkBootSe
c
50
BPB_Reserved
52
12
BS_DrvNum
64
BS_Reserved1
65
BS_BootSig
66
BS_VolID
67
BS_VolLab
71
11
BS_FilSysType
82
FATOffset por
BPB_BytsPerSec. ThisFATSecNum es el nmero de sector del sector de la FAT que
contiene la entrada de
clster de N en el primero FAT. Si desea que el nmero de sector en la segunda FAT, se
agrega a FATSz
ThisFATSecNum; para la tercera FAT, aadir 2 * FATSz, y as sucesivamente.
Ahora lee el nmero del sector ThisFATSecNum (recuerda que esto es un nmero de
sector en relacin con el sector 0 del volumen FAT). Asumir esta se lee en una matriz
de bytes de 8 bits llamado SecBuff. Suponga tambin que el tipo WORD es un sin signo
de 16 bits y que el tipo DWORD es una sin signo de 32 bits.
If(FATType == FAT16)
FAT16ClusEntryVal = *((WORD *) &SecBuff[ThisFATEntOffset]);
Else
FAT32ClusEntryVal = (*((DWORD *) &SecBuff[ThisFATEntOffset])) & 0x0FFFFFFF;
Obtiene el contenido de esa agrupacin. Para definir el contenido de este mismo grupo
que haga lo siguiente:
If(FATType == FAT16)
*((WORD *) &SecBuff[ThisFATEntOffset]) = FAT16ClusEntryVal;
Else {
FAT32ClusEntryVal = FAT32ClusEntryVal & 0x0FFFFFFF;
*((DWORD *) &SecBuff[ThisFATEntOffset]) =
(*((DWORD *) &SecBuff[ThisFATEntOffset])) & 0xF0000000;
*((DWORD *) &SecBuff[ThisFATEntOffset]) =
(*((DWORD *) &SecBuff[ThisFATEntOffset])) | FAT32ClusEntryVal;
Tenga en cuenta cmo funciona el cdigo FAT32 anteriormente. Una entrada de FAT
FAT32 es en realidad slo una entrada de 28-bit. El alto 4 bits de una entrada FAT FAT32
son reservados. La nica vez que los altos 4 bits de entradas FAT FAT32 nunca se debe
cambiar es cuando se formatea el volumen, momento en el que toda la entrada FAT de
32 bits debe ser puesto a cero, incluyendo los altos 4 bits. Un poco ms de explicacin
est en orden aqu, porque este punto sobre las entradas FAT FAT32 parece causar un
gran confusin. Bsicamente entradas FAT de 32 bits no son realmente valores de 32
bits, sino que son slo de 28 bits valores. Por ejemplo, todos estos valores de 32 bits de
racimo de entrada: 0x10000000, 0xF0000000 y 0x00000000 todo indica que el grupo
es libre, porque no tiene en cuenta los altos 4 bits cuando se lee el valor de la entrada
cluster. Si el valor de agrupacin libre de 32-bit es actualmente 0x30000000 y desea
marcar este grupo tan malo almacenando el 0x0FFFFFF7 valor en l. A continuacin, la
entrada de 32 bits contendr el valor 0x3FFFFFF7 cuando haya terminado, ya que debe
mantener los altos 4 bits cuando se escribe en el 0x0FFFFFF7 marca de clster no
vlido. Tome en cuenta que debido a que el valor BPB_BytsPerSec siempre es divisible
entre 2 y 4, que nunca tenga que preocuparse por una entrada FAT16 o FAT FAT32 que
abarca ms de un lmite del sector (esto no es el caso de FAT12).
El cdigo para FAT12 es ms complicado porque hay 1,5 bytes (12 bits) por entrada
FAT.
if (FATType == FAT12)
FATOffset = N + (N / 2);
/* Multiply by 1.5 without using floating point, the divide by 2 rounds DOWN */
ThisFATSecNum = BPB_ResvdSecCnt + (FATOffset / BPB_BytsPerSec);
ThisFATEntOffset = REM(FATOffset / BPB_BytsPerSec);
Ahora tenemos acceso a la entrada FAT como una palabra tal como lo hacemos para
FAT16, pero si el nmero de clster es INCLUSO, slo queremos los bajos de 12 bits de
los 16 bits que haremos ser recuperar, y si el nmero de clster es impar, se slo
quieren que los altos 12 bits de los 16 bits que buscarlo.
FAT12ClusEntryVal = *((WORD *) &SecBuff[ThisFATEntOffset]);
If(N & 0x0001)
FAT12ClusEntryVal = FAT12ClusEntryVal >> 4; /* Cluster number is ODD */
Else
FAT12ClusEntryVal = FAT12ClusEntryVal & 0x0FFF; /* Cluster number is EVEN */
Obtiene el contenido de esa agrupacin. Para definir el contenido de este mismo grupo
que haga lo siguiente:
If(N & 0x0001) {
FAT12ClusEntryVal = FAT12ClusEntryVal << 4; /* Cluster number is ODD */
*((WORD *) &SecBuff[ThisFATEntOffset]) =
(*((WORD *) &SecBuff[ThisFATEntOffset])) & 0x000F;
} Else {
FAT12ClusEntryVal = FAT12ClusEntryVal & 0x0FFF; /* Cluster number is EVEN */
*((WORD *) &SecBuff[ThisFATEntOffset]) =
(*((WORD *) &SecBuff[ThisFATEntOffset])) & 0xF000;
}
*((WORD *) &SecBuff[ThisFATEntOffset]) =
(*((WORD *) &SecBuff[ThisFATEntOffset])) | FAT12ClusEntryVal;
NOTA: Se supone que el operador >> desplaza un valor de bit de 0 en los 4 bits altos y
que la << operador cambia un valor de bit de 0 a los 4 bits bajos. La forma en que los
datos de un archivo se asocia con el archivo es el siguiente. En la entrada del
directorio, el grupo se registra el nmero de la primera clster del archivo. El primer
grupo (extensin) del archivo es el de datos asociados con este primer nmero de
clster, y la ubicacin de los datos en el volumen se calcula a partir el nmero de
clster como se describe anteriormente (clculo de FirstSectorofCluster). Tenga en
cuenta que un archivo de un archivo de longitud cero que no tiene datos asignados a
ella-tiene un primer nmero de clster de 0 colocado en la entrada del directorio. La
ubicacin de esta agrupacin en el FAT (ver clculo anterior de ThisFATSecNum y
ThisFATEntOffset) contiene ya sea una marca de EOC (End Of Clusterchain) o la nmero
de clster de la siguiente clster del archivo. El valor EOC depende de tipo FAT
(suponiendo FATContent es el contenido de la entrada de clster en el FAT se
comprueba para ver si se trata de un COE marca):
IsEOF = FALSE;
If(FATType == FAT12) {
If(FATContent >= 0x0FF8)
IsEOF = TRUE;
} else if(FATType == FAT16) {
If(FATContent >= 0xFFF8)
IsEOF = TRUE;
} else if (FATType == FAT32) {
If(FATContent >= 0x0FFFFFF8)
IsEOF = TRUE;
}
Tenga en cuenta que el nmero de clster cuyo cmulo de entrada en la FAT contiene
la marca de EOC se asigna al archivo y es tambin el ltimo grupo asignado al archivo.
Conductores FAT sistema operativo de Microsoft utilizan la EOC valor 0x0FFF para
FAT12, 0xFFFF para FAT16, FAT32 y 0x0FFFFFFF para cuando se pusieron en el
contenido de un clster para la marca EOC. Existen varias utilidades de disco para los
sistemas operativos de Microsoft que utilice un valor diferente, sin embargo. Tambin
hay una marca especial "de clster no vlido". Cualquier grupo que contiene el "clster
no vlido" valor en su entrada FAT es un grupo que no debe ser colocado en la lista
libre, ya que es propenso a disco errores. El valor "de clster no vlido" es 0x0FF7 para
FAT12, FAT16 para 0xFFF7 y 0x0FFFFFF7 para FAT32. La otra nota relevante es que
estos sectores defectuosos tambin se pierden grupos-grupos que parecen ser
asignado ya que contienen un valor no-cero, pero que no son parte de los archivos
cadena de asignacin. Utilidades de reparacin de disco deben reconocer clsteres
perdidos que contienen este valor especial es tan malo clusters y no cambia el
contenido de la entrada de clster. NOTA: No es posible que la marca de clster no
vlido para ser un nmero de clster asignable en FAT12 y Volmenes FAT16, pero es
factible para 0x0FFFFFF7 ser un nmero de clster asignable en FAT32 volmenes. Para
evitar posibles confusiones por utilidades de disco, sin volumen FAT32 debe
configurarse cada vez de tal manera que 0x0FFFFFF7 es un nmero de clster
asignable. La lista de grupos libres en la FAT no es ms que la lista de todos los grupos
que contienen el valor 0 en su entrada de clster FAT. Tenga en cuenta que este valor
debe ser recuperado como se ha descrito anteriormente como para cualquier otro
Entrada FAT que no es libre. Esta lista de grupos libres no se almacena en ninguna
parte en el volumen, sino que debe ser calculado cuando el volumen est montado
mediante el escaneo de la FAT para las entradas que contienen el valor 0. En
Volmenes FAT32, el sector BPB_FSInfo pueden contener un recuento vlido de
clsteres libres en el volumen. Ver la documentacin del sector fsinfo FAT32. Cules
son los dos grupos reservadas al comienzo de la FAT para? El primer grupo reservado,
FAT [0], contiene el valor del byte BPB_Media en sus 8 bits ms bajos, y todos los
dems bits se ponen a 1. Por ejemplo, si el BPB_Media valor es 0xF8, para FAT12 FAT
[0] = 0x0FF8, para FAT16 FAT [0] = 0xFFF8, y para FAT32 FAT [0] = 0x0FFFFFF8. El
segundo grupo reservado, FAT [1], se establece segn el formato de la EOC marcar. En
FAT12 volmenes, que no se utiliza y est simplemente siempre contiene una marca de
EOC. Para FAT16 y FAT32, el controlador de sistema de archivos puede utilizar las dos
grandes partes de la FAT [1] la entrada de las banderas de volumen sucios (todo otras
partes, siempre se dejan establece en 1). Tenga en cuenta que la ubicacin es algo
diferente para FAT16 y FAT32, porque son los altos 2 bits de la entrada.
For FAT16:
ClnShutBitMask = 0x8000;
HrdErrBitMask = 0x4000;
For FAT32:
ClnShutBitMask = 0x08000000;
HrdErrBitMask = 0x04000000;
de estos "extras" son sectores FAT. Cdigo de formato FAT debera cero el contenido de
estos sectores extra FAT embargo.
* being different may require the first table entries DiskSize value
* to be changed otherwise the cluster count may be to low for FAT16.
*/
DSKSZTOSECPERCLUS DskTableFAT16 [] = {
{ 8400, 0}, /* disks up to 4.1 MB, the 0 value for SecPerClusVal trips an error */
{ 32680, 2}, /* disks up to 16 MB, 1k cluster */
{ 262144, 4}, /* disks up to 128 MB, 2k cluster */
{ 524288, 8}, /* disks up to 256 MB, 4k cluster */
{ 1048576, 16}, /* disks up to 512 MB, 8k cluster */
/* The entries after this point are not used unless FAT16 is forced */
{ 2097152, 32}, /* disks up to 1 GB, 16k cluster */
{ 4194304, 64}, /* disks up to 2 GB, 32k cluster */
{ 0xFFFFFFFF, 0} /* any disk greater than 2GB, 0 value for SecPerClusVal trips an error */
};
/*
* This is the table for FAT32 drives. NOTE that this table includes
* entries for disk sizes smaller than 512 MB even though typically
* only the entries for disks >= 512 MB in size are used.
* The way this table is accessed is to look for the first entry
* in the table for which the disk size is less than or equal
* to the DiskSize field in that table entry. For this table to
* work properly BPB_RsvdSecCnt must be 32, and BPB_NumFATs
* must be 2. Any of these values being different may require the first
* table entries DiskSize value to be changed otherwise the cluster count
* may be to low for FAT32.
*/
DSKSZTOSECPERCLUS DskTableFAT32 [] = {
{ 66600, 0}, /* disks up to 32.5 MB, the 0 value for SecPerClusVal trips an error */
{ 532480, 1}, /* disks up to 260 MB, .5k cluster */
{ 16777216, 8}, /* disks up to 8 GB, 4k cluster */
{ 33554432, 16}, /* disks up to 16 GB, 8k cluster */
{ 67108864, 32}, /* disks up to 32 GB, 16k cluster */
{ 0xFFFFFFFF, 64}/* disks greater than 32GB, 32k cluster */
};
demasiado grande, a expensas de perder unos pocos sectores, el hecho de que este
clculo es sorprendentemente simple ms de lo compensa estar fuera de forma segura
en algunos casos.
FAT32 fsinfo Estructura Sectorial y el sector de inicio de copia de seguridad En un
volumen FAT32, la FAT puede ser una gran estructura de datos, a diferencia de en
FAT16 donde se limita a una mximo de valor de 128K de sectores y FAT12 donde se
limita a un mximo de valor de 6K sectores. Por esta razn, se hace una provisin para
almacenar la "ltima conocida" cuenta agrupacin libre en el FAT32 volumen de forma
que no tiene que ser calculado en cuanto se hizo una llamada a la API de preguntar
cunto libre el espacio que hay en el volumen (como en el extremo de un listado de
directorio). El nmero es el sector fsinfo valor en el campo BPB_FSInfo; para los
sistemas operativos de Microsoft que siempre se establece en 1. Esta es la estructura
del sector fsinfo:
Nombre
Offset
(byte)
0
tamao
(bytes)
4
480
FSI_StrucSig
484
FSI_Free_Count
488
FSI_Nxt_Free
492
12
FSI_LeadSig
FSI_Reserved1
Descripcin
Valor 0x41615252. Esta firma de
plomo se usa para validar que este
es de hecho un sector fsinfo.
Este
campo
est
reservado
actualmente
para
una
futura
expansin. formato FAT32 cdigo
siempre debe inicializar todos los
bytes de este campo es 0. Bytes
Actualmente este campo debe
nunca ser utilizado.
Valor 0x61417272. Otra firma que es
ms localizada en el sector a la
ubicacin de los campos que se
utilizan.
Contiene el ltimo recuento clster
libre conocida en el volumen. Si el
valor es 0xFFFFFFFF, entonces la
cuenta libre es desconocido y debe
ser calculado. Cualquier otro valor se
puede
utilizar,
pero
no
es
necesariamente corregir. Debe estar
registrado rango, al menos, para
asegurarse de que es <= volumen
de recuento de clster.
Esta es una sugerencia para el
conductor FAT. Indica el nmero de
FSI_TrailSig
508
FSI_Reserved2
496
12
Para FAT32, el directorio raz puede ser de tamao variable y es una cadena de
clsteres, como cualquier otro directorio es. El primer grupo del directorio raz de un
volumen FAT32 se almacena en BPB_RootClus. A diferencia de otros directorios, el
directorio raz misma de cualquier tipo FAT no tiene fecha y hora sellos, no tiene un
nombre de archivo (que no sea el nombre del archivo implcito "\"), y no contiene "."
y .. "Archivos como las dos primeras entradas de directorio en el directorio. El nico
otro aspecto especial de la raz directorio es que es el nico directorio en el volumen
FAT para las que es vlido tener un archivo que tiene
slo el bit de atributo ATTR_VOLUME_ID (vase ms adelante).
ATTR_READ_ONLY
ATTR_HIDDEN
ATTR_SYSTEM
ATTR_VOLUME_ID
ATTR_DIRECTORY
ATTR_ARCHIVE
ATTR_LONG_NAME
DIR_NTRes
12
DIR_CrtTimeTenth
13
DIR_CrtTime
DIR_LstAccDate
14
16
18
2
2
2
DIR_FstClusHI
20
DIR_WrtTime
22
DIR_CrtDate
0x01
0x02
0x04
0x08
0x10
0x20
ATTR_READ_ONLY |
ATTR_HIDDEN |
ATTR_SYSTEM |
ATTR_VOLUME_ID
DIR_WrtDate
24
DIR_FstClusLO
26
DIR_FileSize
28
Dir_name [0]
Notas especiales sobre el primer byte (dir_name [0]) de una entrada de
directorio FAT:
Si dir_name [0] == 0xE5, entonces la entrada de directorio es gratuito
(no hay ningn nombre de archivo o directorio en este
entrada).
Si dir_name [0] == 0x00, entonces la entrada de directorio es gratuita
(igual que para 0xE5), y no hay asignado las entradas de directorio
despus de sta (todo el dir_name [0] bytes en todas las entradas
despus de ste tambin se establecen en 0).
El valor especial 0, en lugar del valor 0xE5, indica el cdigo del
controlador de sistema de archivos FAT que el resto de las entradas de
este directorio no necesita ser examinada porque son todos libres.
Si dir_name [0] == 0x05, entonces el carcter de nombre de archivo
real para este byte es 0xE5. 0xE5 es en realidad un valor de byte inicial
KANJI vlida para el conjunto de caracteres utilizado en Japn. El valor
0x05 especial se utiliza para que este caso nombre de archivo especial
para Japn puede ser manejado correctamente y no causa de archivos
FAT cdigo del sistema para pensar que la entrada es libre.
El campo dir_name es en realidad dividida en dos partes: la parte
principal + 8 caracteres del nombre, y el Extensin de 3 caracteres.
Estas dos partes son "el espacio en acolchada" con bytes de 0x20.
Dir_name [0] puede no ser igual a 0x20. Hay una implcita '.' Carcter
entre la parte principal de la nombre y la parte de extensin del nombre
que no est presente en dir_name. Caracteres en minsculas son no se
permite en dir_name (lo que estos personajes son es especfico del pas).
En los directorios FAT todos los nombres son nicos. Mira las primeras
tres ejemplos anteriores. Los diferentes todos los nombres se refieren al
mismo fichero, y slo puede haber un archivo con dir_name set de "FOO
BAR" en cualquier directorio.
DIR_Attr especifica los atributos del archivo:
ATTR_READ_ONLY Indica que se escribe en el archivo debe fallar.
ATTR_HIDDEN Indica que los listados de directorios normales no
deberan mostrar este archivo.
ATTR_SYSTEM Indica que este es un archivo del sistema operativo.
ATTR_VOLUME_ID Slo debe haber un "archivo" en el volumen que tiene
este atributo establecido, y que el archivo debe estar en el directorio
raz. El nombre de este archivo es en realidad la etiqueta para el
volumen. DIR_FstClusHI y DIR_FstClusLO siempre debe ser 0 para la
etiqueta de volumen (no hay datos grupos se asignan al archivo de
etiqueta de volumen). ATTR_DIRECTORY Indica que este archivo es en
realidad un contenedor para otros archivos. ATTR_ARCHIVE Este atributo
admite utilidades de copia de seguridad. Este bit es activado por el
archivo FAT controlador del sistema cuando se crea un archivo, cambiar
de nombre o escrita. Copia de seguridad servicios pblicos podrn
utilizar este atributo para indicar qu archivos del volumen se han
modificado desde la ltima vez que se realiz una copia de seguridad.
Tenga en cuenta que la combinacin de bits ATTR_LONG_NAME atributo
indica que el "archivo" es en realidad parte de la entrada de nombre
largo para algn otro archivo. Consulte la especificacin de nombre de
Info
de:
http://www.ccsinfo.com/forum/viewtopic.php?
t=23969&highlight=fat32
Just removed the dust from my old FAT32 code. Maybe it will be useful for somebody... See
notes in EX_ file.
So the header file (MyMMCFat32.h):
Code:
#defineMAXFILES2
typedefstruct_diskinforec
{
charhJumpCode[3];
charOEMName[8];
int16hBytesPerSector;
charbSectorsPerCluster;
int16Reserved1;
charFATCopies;
int16hMaxRootEntries;
int16hSectors;
charDescriptor;
int16holdSectorsPerFat;
int16hSectorsPerTrack;
int16hNumberofHeads;
int32hNumberofHidden;
int32hNumberofSectors;
int32hSectorsPerFat;
int16hFlags;
int16hFAT32Version;
int32hRootStartCluster;
}diskinforec;
typedefstruct_direntry
{
charsName[8];
char[spam][3];
charbAttr;
charbReserved[8];
int16hClusterH;
int16hTime;
int16hDate;
int16hCluster;
int32wSize;
}DIR;
typedefstruct{
charIOpuffer[512];
DIRDirEntry;
int32CurrentCluster;
int16posinsector;
int32position;
int32dirSector;
int16dirIdx;
charmode;
charFree;
}FILE;
typedefstruct{
int32MMCAddress;
int32FATstartidx;
int32gStartSector;
int32gFirstDataSector;
int16gDirEntryIdx;
int32gDirEntrySector;
int16gFirstEmptyDirEntry;
int32gFirstDirEntryCluster;
}FAT32Vars;
charMMCInit();
voidReadSector(int32sector,char*hova);
voidWriteSector(int32sector,char*honnan);
voidInitFAT();
charFindDirEntry(char*fname,charf);
charfopen(char*fname,charmode);
voidfclose(charf);
voidfflush(charf);
charcwd(char*fname,charf);
voidfputch(charbe,charf);
charfgetch(char*ki,charf);
voidfputstring(char*be,charf);//fputsisreservedinCCSC
int16fread(char*buffer,int16leng,charf);
voidfwrite(char*buffer,int16leng,charf);
charremove(char*fname);
chargetfsize(char*fname,int32*fsiz);
int32gFirstEmptyCluster;
FAT32VarsgFAT32Vars;
diskinforecDiskInfo;
FILEgFiles[MAXFILES];
#byteMMCAddressL=gFAT32Vars
#byteMMCAddressH=gFAT32Vars+1
#byteMMCAddressHL=gFAT32Vars+2
#byteMMCAddressHH=gFAT32Vars+3
#bytegStartSectorL=gFAT32Vars+8
#bytegStartSectorH=gFAT32Vars+9
#bytegStartSectorHL=gFAT32Vars+10
#locateFATTable=0x0800
#locategFiles=0x0A00
#locategFAT32Vars=0x0E70
#locateDiskInfo=0x0E90
#useFAST_IO(C)
#defineChipSelpin_c2
#defineChipClkpin_c3
#defineChipDinpin_c5
//#defineCardInsertedPIN_A4//thesepinsarealreadydefinedinmymainC
file
//#defineREDLEDPIN_E7
//#defineYELLOWLEDPIN_E6//removecommentsorcommentoutlinescontaining
YELLOWLEDrefsinthisfile
//#defineGREENLEDPIN_E5
charIsSelfDir(char*be)
{
if(be[0]=='.'&&be[1]=='.')return0xFF;
elsereturn0;
}
voidMMCOut(charindata)
{
chari;
SSPBUF=indata;
while(!BF);
i=SSPBUF;
}
voidMMC8Clock()
{
chari;
SSPBUF=0xFF;
while(!BF);
i=SSPBUF;
}
charMMCIn()
{
chari;
SSPBUF=0xFF;
while(!BF);
i=SSPBUF;
returni;
}
charMMCInit()
{
charresponse,iii,errcnt;
restart_wdt();
output_high(ChipSel);
output_high(ChipClk);
output_high(ChipDin);
bit_clear(SSPCON1,5);
SSPCON1=0x30;//modifythisnumbertochangeSPIclockrate
SSPSTAT=0;
iii=10;
errcnt=100;
do{
MMCOut(0xFF);
}while(iii);
delay_us(1000);
output_low(ChipClk);
output_low(ChipSel);
MMCOut(0x40);
MMCOut(0x00);
MMCOut(0x00);
MMCOut(0x00);
MMCOut(0x00);
MMCOut(0x95);
MMC8Clock();
response=MMCIn();
output_high(ChipSel);
output_high(ChipClk);
do{
delay_us(1000);
output_low(ChipClk);
output_low(ChipSel);
MMCOut(0x41);
MMCOut(0x00);
MMCOut(0x00);
MMCOut(0x00);
MMCOut(0x00);
MMCOut(0x01);
MMC8Clock();
response=MMCIn();
output_high(ChipSel);
output_high(ChipClk);
MMC8Clock();
errcnt;
}while(response&&errcnt);
returnerrcnt;
}
int16GetCurrentDOSDate()
{
int16retval;
retval=myrec.tm_year1980;
retval<<=9;
retval|=((int16)myrec.tm_mon<<5);
retval|=(int16)myrec.tm_mday;
returnretval;
}
int16GetCurrentDOSTime()
{
int16retval;
retval=myrec.tm_hour;
retval<<=11;
retval|=((int16)myrec.tm_min<<5);
retval|=(int16)myrec.tm_sec>>1;
returnretval;
}
voidReadSector(int32sector,char*hova)
{
charerrs,response;
charcnt2,cnt3;
#bytesectorL=sector
#bytesectorH=sector+1
#bytesectorHL=sector+2
if(input(CardInserted))return;
Disable_interrupts(GLOBAL);
Restart_wdt();
MMCAddressL=0;
MMCAddressH=sectorL;
MMCAddressHL=sectorH;
MMCAddressHH=sectorHL;
gFAT32Vars.MMCAddress<<=1;
output_low(ChipClk);
output_low(ChipSel);
MMCOut(0x51);
MMCOut(MMCAddressHH);
MMCOut(MMCAddressHL);
MMCOut(MMCAddressH&0xFE);
MMCOut(0);
MMCOut(0x01);
errs=8;
do{
response=MMCIn();
}while(errs&&response==0xFF);
errs=50;
do{
response=MMCIn();
if(response==0xFE)break;
delay_ms(1);
}while(errs);
*0xFE9=(int16)hova;
cnt3=2;
cnt2=0;
do{
do{
SSPBUF=0xFF;
while(!BF);
*0xFEE=SSPBUF;
}while(cnt2);
}while(cnt3);
response=MMCIn();
response=MMCIn();
output_high(ChipSel);
output_high(ChipClk);
Enable_interrupts(GLOBAL);
}
voidWriteSector(int32sector,char*honnan)
{
charerrs,response;
charcnt2,cnt3;
#bytesectorL=sector
#bytesectorH=sector+1
#bytesectorHL=sector+2
if(input(CardInserted))return;
Disable_interrupts(GLOBAL);
Restart_wdt();
MMCAddressL=0;
MMCAddressH=sectorL;
MMCAddressHL=sectorH;
MMCAddressHH=sectorHL;
gFAT32Vars.MMCAddress<<=1;
response=0;
output_low(ChipClk);
output_low(ChipSel);
MMCOut(0x58);
MMCOut(MMCAddressHH);
MMCOut(MMCAddressHL);
MMCOut(MMCAddressH&0xFE);
MMCOut(0);
MMCOut(0x01);
MMC8Clock();
errs=8;
do{
response=MMCIn();
}while(errs&&response==0xFF);
if(response){
output_high(ChipSel);
output_high(ChipClk);
MMC8Clock();
Enable_interrupts(GLOBAL);
return;
}
MMC8Clock();
MMCOut(0xFE);
*0xFE9=(int16)honnan;
cnt3=2;
cnt2=0;
do{
do{
SSPBUF=*0xFEE;
while(!BF);
}while(cnt2);
}while(cnt3);
MMCOut(0x00);
MMCOut(0x01);
response=MMCIn();
response^=0xE5;
if(response){
gotoendwr3;
}
do{
response=MMCIn();
}while(response==0);
response=0;
endwr3:
output_high(ChipSel);
output_high(ChipClk);
MMC8Clock();
Enable_interrupts(GLOBAL);
}
voidInitFAT()
{
int32actsector;
chari;
gFirstEmptyCluster=0;
gFAT32Vars.gStartSector=0;
ReadSector(gFAT32Vars.gStartSector,gFiles[MAXFILES1].IOpuffer);
if(gFiles[MAXFILES1].IOpuffer[0]!=0xEB){
gStartSectorL=gFiles[MAXFILES1].IOpuffer[0x1C6];
gStartSectorH=gFiles[MAXFILES1].IOpuffer[0x1C7];
gStartSectorHL=gFiles[MAXFILES1].IOpuffer[0x1C8];
ReadSector(gFAT32Vars.gStartSector,gFiles[MAXFILES1].IOpuffer);
}
memcpy(&DiskInfo,gFiles[MAXFILES1].IOpuffer,sizeof(DiskInfo));
actsector=gFAT32Vars.gStartSector+DiskInfo.Reserved1;
ReadSector(actsector,FATTable);
gFAT32Vars.FATstartidx=0;
gFAT32Vars.gFirstDataSector=gFAT32Vars.gStartSector+
DiskInfo.FATCopies*DiskInfo.hSectorsPerFat+DiskInfo.Reserved12;
for(i=0;i<MAXFILES;i++)
gFiles[i].Free=TRUE;
}
int32GetNextCluster(int32curcluster)
{
int32actsector;
int32clpage;
charclpos;
clpage=curcluster>>7;
clpos=curcluster&0x7F;
if(clpage!=gFAT32Vars.FATstartidx){//readintherequestedpage
actsector=gFAT32Vars.gStartSector+DiskInfo.Reserved1+clpage;
ReadSector(actsector,FATTable);
gFAT32Vars.FATstartidx=clpage;
}
return(FATTable[clpos]);
}
voidSetClusterEntry(int32curcluster,int32value)
{
int32actsector;
int32clpage;
charclpos;
clpage=curcluster>>7;
clpos=curcluster&0x7F;
actsector=gFAT32Vars.gStartSector+DiskInfo.Reserved1+clpage;
if(clpage!=gFAT32Vars.FATstartidx){
ReadSector(actsector,FATTable);
gFAT32Vars.FATstartidx=clpage;
}
FATTable[clpos]=value;
WriteSector(actsector,FATTable);
actsector+=DiskInfo.hSectorsPerFat;
WriteSector(actsector,FATTable);
}
voidClearClusterEntry(int32curcluster)
{
int32actsector;
int32clpage;
charclpos;
clpage=curcluster>>7;
clpos=curcluster&0x7F;
if(clpage!=gFAT32Vars.FATstartidx){
actsector=gFAT32Vars.gStartSector+DiskInfo.Reserved1+
gFAT32Vars.FATstartidx;
WriteSector(actsector,FATTable);
actsector+=DiskInfo.hSectorsPerFat;
WriteSector(actsector,FATTable);
actsector=gFAT32Vars.gStartSector+DiskInfo.Reserved1+clpage;
ReadSector(actsector,FATTable);
gFAT32Vars.FATstartidx=clpage;
}
FATTable[clpos]=0;
}
int32FindFirstFreeCluster()
{
int32i,st,actsector,retval;
charj;
st=gFirstEmptyCluster;
for(i=st;i<DiskInfo.hSectorsPerFat;i++){
if(i!=gFAT32Vars.FATstartidx){
actsector=gFAT32Vars.gStartSector+DiskInfo.Reserved1+i;
ReadSector(actsector,FATTable);
gFAT32Vars.FATstartidx=gFirstEmptyCluster=i;
}
for(j=0;j<128;j++)
if(FATTable[j]==0){
retval=i;
retval<<=7;
retval|=j;
returnretval;
}
}
return0x0FFFFFFF;
}
voidConvertFilename(DIR*beDir,char*name)
{
chari,j,c;
j=0;
name[0]=0;
for(i=0;i<8;i++){
c=beDir>sName[i];
if(c=='')break;
name[j++]=c;
}
for(i=0;i<3;i++){
c=beDir>[spam][i];
if(c==''||c==0)break;
if(!i)name[j++]='.';
name[j++]=c;
}
name[j++]=0;
}
voidGetDOSName(DIR*pDir,char*fname)
{
chari,j,leng,c,toext;
toext=FALSE;
j=0;
leng=strlen(fname);
for(i=0;i<8;i++)
pDir>sName[i]='';
for(i=0;i<3;i++)
pDir>[spam][i]='';
for(i=0;i<leng;i++){
c=fname[i];
c=toupper(c);
if(c=='.'){
toext=TRUE;
continue;
}
if(toext)pDir>[spam][j++]=c;
elsepDir>sName[i]=c;
}
}
voidReadRootDirectory(charfil)
{
int32actsector;
if(fil>(MAXFILES1))return;
actsector=gFAT32Vars.gStartSector+
DiskInfo.FATCopies*DiskInfo.hSectorsPerFat+DiskInfo.Reserved1;
ReadSector(actsector,gFiles[fil].IOpuffer);
gFAT32Vars.gDirEntrySector=actsector;
gFiles[fil].dirSector=actsector;
gFiles[fil].dirIdx=0;
memcpy(&(gFiles[fil].DirEntry),gFiles[fil].IOpuffer,32);
gFiles[fil].CurrentCluster=DiskInfo.hRootStartCluster;
}
charFindDirEntry(char*fname,charf)
{
DIR*pDir;
int16i;
charfilename[16];
int32nextcluster,actsector;
if(f>(MAXFILES1))returnFALSE;
gFAT32Vars.gFirstEmptyDirEntry=0xFFFF;
gFAT32Vars.gFirstDirEntryCluster=0x0FFFFFFF;
do{
pDir=(DIR*)(gFiles[f].IOpuffer);
for(i=0;i<16;i++){
if((pDir>sName[0]==0xE5||pDir>sName[0]==0)&&
gFAT32Vars.gFirstEmptyDirEntry==0xFFFF){//storefirstfree
gFAT32Vars.gFirstEmptyDirEntry=i;
gFAT32Vars.gFirstDirEntryCluster=gFiles[f].CurrentCluster;
}
if(pDir>sName[0]==0)returnFALSE;
ConvertFilename(pDir,filename);
if(!strcmp(filename,fname)){
memcpy(&(gFiles[f].DirEntry),pDir,32);
gFiles[f].dirIdx=i;
gFAT32Vars.gDirEntryIdx=i;
returnTRUE;
}
pDir++;
}
nextcluster=GetNextCluster(gFiles[f].CurrentCluster);
if(nextcluster!=0x0FFFFFFF&&nextcluster!=0){
actsector=nextcluster+gFAT32Vars.gFirstDataSector;
ReadSector(actsector,gFiles[f].IOpuffer);
gFAT32Vars.gDirEntrySector=actsector;
gFiles[f].dirSector=actsector;
gFiles[f].CurrentCluster=nextcluster;
}
}while(nextcluster!=0x0FFFFFFF&&nextcluster!=0);
returnFALSE;
}
//fileI/Oroutines
char*TryFile(char*fname,char*f)
{
chari,leng;
char*filename;
*f=0xFF;
for(i=0;i<MAXFILES;i++){
if(gFiles[i].Free){
*f=i;
break;
}
}
if(*f==0xFF)return0;
ReadRootDirectory(*f);
filename=fname;
leng=strlen(fname);
for(i=0;i<leng;i++){
if(fname[i]=='/'){
fname[i]=0;
if(!cwd(filename,*f)){
gFiles[*f].Free=TRUE;
return0;
}
filename=fname+i+1;
}
}
returnfilename;
}
charfcreate(charf,char*fname)
{
DIR*pDir;
int32actsector,actcl;
int16i;
if(f>(MAXFILES1))returnFALSE;
if(gFAT32Vars.gFirstDirEntryCluster==0x0FFFFFFF){
//extendthedirectoryfile!!!
gFAT32Vars.gFirstDirEntryCluster=FindFirstFreeCluster();
gFAT32Vars.gFirstEmptyDirEntry=0;
SetClusterEntry(gFiles[f].CurrentCluster,gFAT32Vars.gFirstDirEntryCluster);
SetClusterEntry(gFAT32Vars.gFirstDirEntryCluster,0x0FFFFFFF);
actsector=gFAT32Vars.gFirstDirEntryCluster+
gFAT32Vars.gFirstDataSector;
for(i=0;i<512;i++)
gFiles[f].IOpuffer[i]=0;
WriteSector(actsector,gFiles[f].IOpuffer);
}
actsector=gFAT32Vars.gFirstDirEntryCluster+
gFAT32Vars.gFirstDataSector;
ReadSector(actsector,gFiles[f].IOpuffer);
pDir=(DIR*)(&(gFiles[f].IOpuffer[32*gFAT32Vars.gFirstEmptyDirEntry]));
gFiles[f].dirSector=actsector;
gFiles[f].dirIdx=gFAT32Vars.gFirstEmptyDirEntry;
GetDOSName(pDir,fname);
pDir>bAttr=0;
actcl=FindFirstFreeCluster();
pDir>hCluster=actcl&0xFFFF;
pDir>hClusterH=actcl>>16;
SetClusterEntry(actcl,0x0FFFFFFF);
pDir>wSize=0;
gFiles[f].position=0;
pDir>hDate=GetCurrentDOSDate();
pDir>hTime=GetCurrentDOSTime();
WriteSector(actsector,gFiles[f].IOpuffer);
memcpy(&(gFiles[f].DirEntry),pDir,32);
returnTRUE;
}
int32ComposeCluster(charf)
{
int32retval;
retval=gFiles[f].DirEntry.hClusterH;
retval<<=16;
retval|=gFiles[f].DirEntry.hCluster;
returnretval;
}
charfopen(char*fname,charmode)
{
charfound;
charf;
int32actsector,actcluster,nextcluster;
char*filename;
if(input(CardInserted))return0xFF;
output_high(YELLOWLED);
filename=TryFile(fname,&f);
if(filename==0)return0xFF;
found=FALSE;
found=FindDirEntry(filename,f);
if(!found){
if(mode=='r'){
gFiles[f].Free=TRUE;
return0xFF;
}else{
if(!fcreate(f,filename))return0xFF;
found=TRUE;
}
}
if(found){
gFiles[f].Free=FALSE;
gFiles[f].mode=mode;
if(mode=='a'){
gFiles[f].position=gFiles[f].DirEntry.wSize;
actcluster=ComposeCluster(f);
while(actcluster!=0x0FFFFFFF&&nextcluster!=0){
nextcluster=GetNextCluster(actcluster);
if(nextcluster==0x0FFFFFFF||nextcluster==0)break;
actcluster=nextcluster;
}
actsector=actcluster+gFAT32Vars.gFirstDataSector;
ReadSector(actsector,gFiles[f].IOpuffer);
gFiles[f].CurrentCluster=actcluster;
gFiles[f].posinsector=gFiles[f].position&0x01FF;
if(gFiles[f].posinsector==0&&gFiles[f].position!=0)
gFiles[f].posinsector=512;
}else{
gFiles[f].position=0;
actsector=ComposeCluster(f);
actsector+=gFAT32Vars.gFirstDataSector;
ReadSector(actsector,gFiles[f].IOpuffer);
gFiles[f].CurrentCluster=ComposeCluster(f);
gFiles[f].posinsector=0;
}
}
returnf;
}
voidfclose(charf)
{
output_low(YELLOWLED);
if(f>(MAXFILES1))return;
if((gFiles[f].mode=='a')||(gFiles[f].mode=='w'))fflush(f);
gFiles[f].Free=TRUE;
}
voidfflush(charf)
{
int32actsector;
DIR*pDir;
if(f>(MAXFILES1))return;
actsector=gFiles[f].CurrentCluster+gFAT32Vars.gFirstDataSector;
WriteSector(actsector,gFiles[f].IOpuffer);
ReadSector(gFiles[f].dirSector,gFiles[f].IOpuffer);
pDir=(DIR*)(&(gFiles[f].IOpuffer[32*gFiles[f].dirIdx]));
if(gFiles[f].DirEntry.bAttr&0x10)pDir>wSize=0;//ifitisa
directory
elsepDir>wSize=gFiles[f].position;
pDir>hDate=GetCurrentDOSDate();
pDir>hTime=GetCurrentDOSTime();
WriteSector(gFiles[f].dirSector,gFiles[f].IOpuffer);
ReadSector(actsector,gFiles[f].IOpuffer);
}
charcwd(char*fname,charf)
{
int32actsector;
if(f>(MAXFILES1))returnFALSE;//justincaseofoveraddressing
if(IsSelfDir(fname))returnTRUE;//alreadyinRootdir
if(!FindDirEntry(fname,f))returnFALSE;//notfound
actsector=ComposeCluster(f);
actsector+=gFAT32Vars.gFirstDataSector;//readcurrentdir
ReadSector(actsector,gFiles[f].IOpuffer);
gFAT32Vars.gDirEntrySector=actsector;
gFiles[f].dirSector=actsector;
gFiles[f].CurrentCluster=ComposeCluster(f);
returnTRUE;
}
voidfputch(charbe,charf)
{
int32nextcluster,actsector;
if(f>(MAXFILES1))return;
if(gFiles[f].posinsector==512){
actsector=gFiles[f].CurrentCluster+gFAT32Vars.gFirstDataSector;
WriteSector(actsector,gFiles[f].IOpuffer);
nextcluster=FindFirstFreeCluster();
if(nextcluster!=0x0FFFFFFF&&nextcluster!=0){
SetClusterEntry(gFiles[f].CurrentCluster,nextcluster);
SetClusterEntry(nextcluster,0x0FFFFFFF);
actsector=nextcluster+gFAT32Vars.gFirstDataSector;
ReadSector(actsector,gFiles[f].IOpuffer);
gFiles[f].CurrentCluster=nextcluster;
gFiles[f].posinsector=0;
}
}
gFiles[f].IOpuffer[gFiles[f].posinsector]=be;
gFiles[f].posinsector++;
gFiles[f].position++;
}
voidfputstring(char*be,charf)
{
int16leng,i;
if(f>(MAXFILES1))return;
leng=strlen(be);
for(i=0;i<leng;i++)
fputch(be[i],f);
}
int16fread(char*buffer,int16leng,charf)
{
int16i,retv;
charc,v;
if(f>(MAXFILES1))return0;
retv=0;
for(i=0;i<leng;i++){
v=fgetch(&c,f);
if(v){
buffer[i]=c;
retv++;
}
elsebreak;
}
returnretv;
}
voidfwrite(char*buffer,int16leng,charf)
{
int16i;
if(f>(MAXFILES1))return;
for(i=0;i<leng;i++)
fputch(buffer[i],f);
}
charfgetch(char*ki,charf)
{
int32nextcluster,actsector;
if(f>(MAXFILES1))returnFALSE;
if(gFiles[f].position>=gFiles[f].DirEntry.wSize)returnFALSE;
*ki=gFiles[f].IOpuffer[gFiles[f].posinsector];
gFiles[f].posinsector++;
gFiles[f].position++;
if(gFiles[f].posinsector==512){
nextcluster=GetNextCluster(gFiles[f].CurrentCluster);
if(nextcluster!=0x0FFFFFFF&&nextcluster!=0){
actsector=nextcluster+gFAT32Vars.gFirstDataSector;
ReadSector(actsector,gFiles[f].IOpuffer);
gFiles[f].CurrentCluster=nextcluster;
gFiles[f].posinsector=0;
}
}
returnTRUE;
}
charremove(char*fname)
{
chari,found;
charf;
DIR*pDir;
int32nextcluster,currentcluster;
char*filename;
filename=TryFile(fname,&f);
if(filename==0)returnFALSE;
found=FindDirEntry(filename,f);
if(!found){
gFiles[f].Free=TRUE;
returnFALSE;
}
output_high(YELLOWLED);
pDir=(DIR*)(&(gFiles[f].IOpuffer[32*gFAT32Vars.gDirEntryIdx]));
pDir>sName[0]=0xE5;
for(i=1;i<8;i++)
pDir>sName[i]='';
for(i=0;i<3;i++)
pDir>[spam][i]='';
WriteSector(gFAT32Vars.gDirEntrySector,gFiles[f].IOpuffer);
currentcluster=ComposeCluster(f);
while(currentcluster!=0x0FFFFFFF&&nextcluster!=0){
nextcluster=GetNextCluster(currentcluster);
ClearClusterEntry(currentcluster);
currentcluster=nextcluster;
}
ClearClusterEntry(currentcluster);
SetClusterEntry(currentcluster,0);
currentcluster=gFAT32Vars.gStartSector+DiskInfo.Reserved1+
gFAT32Vars.FATstartidx;
WriteSector(currentcluster,FATTable);
currentcluster+=DiskInfo.hSectorsPerFat;
WriteSector(currentcluster,FATTable);
gFiles[f].Free=TRUE;
output_low(YELLOWLED);
returnTRUE;
}
chargetfsize(char*fname,int32*fsiz)
{
charfound;
charf;
DIR*pDir;
char*filename;
filename=TryFile(fname,&f);
if(filename==0)returnFALSE;
found=FindDirEntry(filename,f);
if(!found){
gFiles[f].Free=TRUE;
returnFALSE;
}
pDir=(DIR*)(&(gFiles[f].IOpuffer[32*gFAT32Vars.gDirEntryIdx]));
gFiles[f].Free=TRUE;
*fsiz=pDir>wSize;
returnTRUE;
}
IuseitwithaPIC18F6720(3.5kByteRAM)HWSPI@11.0592MHzcrystal;
testedwith64256MBMMCs
TheRAMareaismovedtoupperregionby#locatedirectives
TheMMChas2GNDpins;oneofthemispulledupbyaresistor(10k)to
+5VandconnectedtoPIN_A4
sotheMMCis"hotswappable".
TheMMChastoformatFAT32,512bytes/cluster
Thenumberofopenedfilesatatimeislimitedto2becauseofRAM
limitations(somedsPICshave8KRAM...;))
Nolongnames;useDOSlike8+3nameformat
NoMKDIRandRMDIRfunctions(notyet...)socreatethesubdirsright
aftertheformat(anduse8+3capitalcharacters...)
IusethefollowingDOSbatchinXP:
formatI:/A:512/V:TOMI/FS:FAT32
mkdirI:\BERS
mkdirI:\WINDS
Use'/'asdirectoryseparator,e.g."MYDIR/ELEMENT.WND"
"MYDIR/SUBDIR/OTHER.TXT"etc.
Thepossiblemodesforfileopen(charandNOTstringasinstd.C):
'r'(read)'w'(write;thepreviouscontentwilloverwritten)'a'(append)
fputsisreservedkeywordbyCCSCsousefputstring()instead
IntheexampletheEVENT.LOGfileusestheHungariandateformat
(YYYY.MM.DD.HH.mm.SS)sorry...
Therearesomefunctionsnormallynottouse:
fflush(f)UseitonlyifyouwanttoflushdataintoMMCwhileyou
keepthefileopened
TryFile()triestoopenthefileincl.resolvingthepath
cwd(fname,f)isusedbyTryFiletoresolvethepathname
fcreate()Ifyouopenafilewith'a'or'w'thefileis
automaticallycreatedifnotexist
*/
#include<18F6720.h>
..........
#include<string.h>
typedefstruct{
unsignedlongtm_year;
chartm_mon;
chartm_day;
chartm_mday;
chartm_hour;
chartm_min;
chartm_sec;
}TimeRecord;
....................
TimeRecordmyrec;//thisvariableisupdatedinregularintervalsin
DoIdle()
....................
....................
....................
#include"MyMMCFat32.h"
#include"MyMMCFat32.c"
....................
....................
voidmain()
{
charf,v,msg[64],gfilename[32];
chargPrevCard,gActCard;//previousandactualcardstates(inserted,
removed)
....................//otherdeclarations
....................
....................//INITcodeparts
....................
InitClockInt();//inittheclockchip
ReadClock();//readthecurrenttime
if(!input(CardInserted)){//ifMMCcardisinplace
do{
output_high(REDLED);
v=MMCInit();//initthecard
delay_ms(50);
output_low(REDLED);
delay_ms(50);
}while(!v);
output_high(YELLOWLED);
InitFAT();//initthefilesystem
output_low(YELLOWLED);
output_low(REDLED);
}
..................
strcpy(gfilename,"EVENTS.LOG");
f=fopen(gfilename,'a');//openEVENTS.LOGforappend
if(f<MAXFILES){
sprintf(msg,"%04lu.%02u.%02u.%02u:%02u:%02u
",myrec.tm_year,myrec.tm_mon,myrec.tm_mday,myrec.tm_hour,myrec.tm_min,myrec.t
m_sec);
fputstring(msg,f);
strcpy(msg,"Systemstarted\r\n");
fputstring(msg,f);
fclose(f);
}
while(1){
restart_wdt();
ResetPorts();
DoIdle();//Idlefunctionincl.clockupdate
....................
....................
gActCard=input(CardInserted);
if(gActCard)output_high(REDLED);
elseoutput_low(REDLED);
if(gActCard==0&&gPrevCard!=0){//cardwaspulledoutthen
pushedbacknow
delay_ms(50);
do{
output_high(REDLED);
v=MMCInit();
delay_ms(50);
output_low(REDLED);
delay_ms(50);
}while(!v);
output_high(YELLOWLED);
InitFAT();
output_low(YELLOWLED);
output_low(REDLED);
delay_ms(50);
strcpy(gfilename,"EVENTS.LOG");
f=fopen(gfilename,'a');
if(f<MAXFILES){
sprintf(msg,"%04lu.%02u.%02u.%02u:%02u:%02u
",myrec.tm_year,myrec.tm_mon,myrec.tm_mday,myrec.tm_hour,myrec.tm_min,myrec.t
m_sec);
fputstring(msg,f);
strcpy(msg,"Memorycardreplacement\r\n");
fputstring(msg,f);
fclose(f);
}
}
gPrevCard=gActCard;
}
}
/*othershortexamples:
1:tosendoutafilecontenttoserialline
strcpy(gfilename,"SMSDATA.TXT");
f=fopen(gfilename,'r');
if(f<MAXFILES){
while(fgetch(&c,f))fputc(c,HOST2);
fclose(f);
}
2:tosavedailymeasures:
sprintf(gfilename,"BERS/%04lu%02u
%02u.BER",myrec.tm_year,myrec.tm_mon,myrec.tm_mday);//thefilenameis
YYYYMMDD.BER
f=fopen(gfilename,'a');
for(actidx=0;actidx<22;actidx++){//tosavethelast22updated
measures
if(!bit_test(saveflags,actidx))continue;//skipifthisrecordis
notupdated
gBER=gLastBERs[actidx];
if(f<MAXFILES)fwrite(&gBER,sizeof(gBER),f);
}
fclose(f);
*/
Sorry for that, always include "my6720.h" what looks like this:
Code:
#byteSTATUS=0xFD8
#bitbCARRY=STATUS.0
#byteport_A=0xF80
#byteport_B=0xF81
#byteport_C=0xF82
#byteport_D=0xF83
#byteport_E=0xF84
#byteport_F=0xF85
#byteport_G=0xF86
#bytetris_A=0xF92
#bytetris_B=0xF93
#bytetris_C=0xF94
#bytetris_D=0xF95
#bytetris_E=0xF96
#bytetris_F=0xF97
#bytetris_G=0xF98
#bytePCON=0xFD0
#bytebRCSTA=0xFAB
#definebCREN4
#definebOERR2
#byteSSPADD=0xFC8
#byteSSPCON1=0xFC6
#byteSSPCON2=0xFC5
#byteSSPBUF=0xFC9
#byteSSPSTAT=0xFC7
#bytePIR1=0xF9E
#bytePIE1=0xF9D
#bytePIR2=0xFA1
#bitSSPOV=SSPCON1.6
#bitSEN=SSPCON2.0
#bitRSEN=SSPCON2.1
#bitPEN=SSPCON2.2
#bitRCEN=SSPCON2.3
#bitACKEN=SSPCON2.4
#bitACKDT=SSPCON2.5
#bitACKSTAT=SSPCON2.6
#bitSSPIF=PIR1.3
#bitBCLIF=PIR2.3
#bitBF=SSPSTAT.0
Other functions
Posted: Mon Mar 26, 2007 2:43 am
Some people have problems using my FAT32 code especially with undefined functions.
You can find below some short explanations.
1. The clock functions. I use a Ricoh clock chip to get a real time clock because my target circuit
is a data logger.
InitClockInt() funtion sets up the INT_A output of the chip as 32768Hz clock output so it is called
only once in early main() in initialization section. It is then connected to the PIC's TIMER1 input
to get an interrupt in every 2 seconds. The logger has battery-backup solar power supply so I
have to use Sleep() to minimize the power consumption. The target board is waked up in every
2 seconds.
2. ReadClock() functions reads out the current date and time and stores the data in a standard
"struct tm" structure. The definition:
Code:
typedefstruct{
unsignedlongtm_year;
chartm_mon;
chartm_day;
chartm_mday;
chartm_hour;
chartm_min;
chartm_sec;
}RAMRecord;
It is important to handle the creation/modification dates in a file system if it is used for data
loggers. If you don't want to use correct times then simply use a fixed date/time or you can use
a software clock.
3. ResetPorts() function is called as frequently as possible to set up the port TRIS registers,
timer settings, etc. It is an old Microchip suggession to make a stable card in a noisy
environment (the TRIS registers could be corrupted by high level noises). If you have a stable
power supply and could keep external noises in an affordable low level then simply use an empty
function:
Code:
voidResetPorts()
{
}
4. DoIdle() function is called when a TIMER1 interrupt occurs. So normally it is called in every 2
seconds. It is the main data logger function. A small example what it has to do:
a/ Update the clock structure by calling ReadClock()
b/ Get the current wind speed and direction. Store it on MMC if necessary.
c/ If the old minute differs from the newly read then one minute is elapsed; read the
temperatures, pressure, etc. so get the "one minute averages" and store them in a file (MMC).
d/ After these, call Restart_wdt() and Sleep() to enter into sleep mode and to wait the next
timer1 interrupt.