SD
Contenido
Descripción
La librería SD.h de SparkFun habilita un Arduino para la interacción con tarjetas SD (Secure Digital) mediante el protocolo Serial Peripheral Interface (SPI). A pesar de que existen tres tamaños distintos, todos operan exactamente de la misma manera (a determinada capacidad); por lo tanto, esta librería funciona con todos los tamaños.
Debido a que utiliza SPI, la conexión debe realizarse hacia los respectivos pines del Arduino; salvo SS/CS, este puede conectarse en cualquier pin digital libre.
Nota: la librería soporta tarjetas SD del estándar SC y HC; por esta razón, la capacidad máxima soportada es de 32 GB.
Nota: la librería está preinstalada junto con la IDE de Arduino, no es necesario descargarla.
Nota: debido a limitaciones de la librería y sistema de archivos compatibles, el tamaño máximo por archivo es de 4 GB o 4294967295 bytes.
Formato de la ruta de acceso
Esta librería utiliza el formato de rutas de UNIX/Linux: el nombre de las carpetas involucradas se separa con / (barra inclinada o slash), siendo el destino final el último nombre de la secuencia. Por ejemplo:
ruta/hacia/el/archivo/que/buscamos.txt
Siendo ruta, hacia, el, archivo y que las carpetas que nos llevan al archivo buscamos.txt
Ese destino no tiene que ser solamente un archivo regular, también podría ser otra carpeta.
Si es algo que queremos colocar o ubicar en la "raíz", basta con simplemente colocar el nombre del elemento. Por ejemplo:
datos.txt
Esto hará que el archivo datos.txt sea creado o buscado en el directorio raíz; en otras palabras, fuera de toda carpeta.
Nota: ya que el directorio de trabajo de la librería siempre es la raíz, da igual que la ruta sea absoluta (con / al comienzo) o relativa (sin / al comienzo).
Nota: para efectos del sistema de archivos, los nombres no son sensibles a las mayúsculas; por lo tanto, datos.txt, Datos.txt y DATOS.TXT hacen referencia al mismo archivo. Lo mismo aplica para directorios/carpetas.
Nombres SFN (8.3)
Parte de la escritura de rutas también involucra respetar el formato SFN (Short File Name o nombre corto de archivo), el cuál sigue estas reglas:
- El nombre del elemento debe tener como mínimo 1 carácter, y como máximo 8 caracteres.
- Si es un archivo regular, debe haber un único punto (.) justo después del nombre.
- Si es un archivo regular, deben haber de 1 a 3 caracteres después del antes mencionado punto. Esto es lo que se conoce como la "extensión", una forma burda (pero muy usada en Windows) de etiquetar archivos por su contenido (ej.: txt para texto plano, jpg para imágenes codificadas en JPEG, mp3 para audio codificado en MPEG capa 3, etc.).
Nota: deduciendo de las reglas anteriores, los directorios/carpetas solo deben cumplir la primera; no debe haber punto (.) ni extensión en el nombre.
Caracteres permitidos
En el nombre puede venir cualquier carácter, excepto los siguientes:
-
" * + , / : ; < = > ? \ [ ] | - Los que tienen un valor decimal del 0 al 31
- El carácter de valor decimal 127
- El punto (.) sólo si no es antecedido por al menos un caracter permitido.
Técnicamente se permite el carácter espaciador y los del ASCII extendido (valor decimal del 128 al 255), sin embargo el primero no se recomienda porque puede hacer más complicado programar la generación de rutas; y lo segundo tampoco ya que la codificación no es estándar entre regiones geográficas (lo que puede llevar a una interpretación errónea del nombre en cuestión), eso sin contar que si el primer carácter es de valor 0xE5 (229 decimal), la librería podría después mal interpretarlo como un archivo eliminado (que no existe).
Curiosamente, las letras minúsculas están prohibidas; sin embargo esto no es cierto al crear e ingresar la ruta, ya que la librería automáticamente usa, en su lugar, las respectivas contrapartes mayúsculas al procesarla.
La clase SD
Es un objeto preinstanciado que se utiliza para iniciar la tarjeta y realizar operaciones generales sobre el sistema de archivos (FAT en sus versiones de 16 y 32 bits; exFAT no es compatible).
| Métodos | Descripción |
|---|---|
| SD.begin() | Intenta inicializar la tarjeta SD al modo SPI, para así obtener de esta la información necesaria para empezar a utilizarla. |
| SD.end() | Devuelve la librería al estado inicial; útil para remover, "en caliente" y de forma segura, la tarjeta. |
| SD.open() | Abre un archivo o una carpeta. |
| SD.exists() | Verifica si determinado archivo o carpeta realmente existe en la tarjeta. |
| SD.remove() | Elimina un archivo. |
| SD.mkdir() | Crea un directorio (carpeta). |
| SD.rmdir() | Elimina un directorio (carpeta). |
Nota: prácticamente ningún otro método funcionará si no se inicializa de antemano la tarjeta SD.
La clase File
Es un objeto que representa la instancia de un fichero (archivo) o directorio (carpeta) dentro de la tarjeta SD; con este se interactúa directamente sobre ellos. Se crea mediante las funciones SD.open() o File.openNextFile().
Hereda de la clase Stream, lo que quiere decir que prácticamente comparte la mayoría de métodos (y funcionalidad) de incluso la clase Serial. Que algunos no sean mencionados en esta página, no quiere decir que no se puedan utilizar.
Nota: a partir de la versión 1.0 de la IDE de Arduino, se permite tener múltiples archivos abiertos a la vez.
Nota: El flujo de entrada y salida de esta clase se categorizan como por bloques.
Nota: este objeto se puede introducir directamente en un contexto booleano (ej.: como condición de un if... else); se evaluará como verdadero o true si el archivo/carpeta que representa está abierto/a en dicha instancia, falso o false en el caso contrario.
| Método | Descripción |
|---|---|
| File.read() | Lee un byte/caracter o varios del archivo. |
| File.peek() | Lee un byte/caracter del archivo sin avanzar al siguiente. |
| File.available() | Retorna la cantidad de bytes/caracteres disponibles para leer (antes de llegar al final del archivo). |
| File.write() | Escribe un byte/caracter o varios al archivo. Suele usarse para archivos binarios. |
| File.print() | Escribe una representación textual de un dato (o una cadena de caracteres) al archivo. Suele usarse para archivos de texto plano. |
| File.println() | Igual al anterior, excepto que agrega una nueva línea de texto. |
| File.flush() | Fuerza la actualización de los datos en la tarjeta SD. |
| File.close() | Cierra el archivo (o carpeta) para liberar correctamente cualquier recurso que esté siendo utilizado por esta instancia. |
| File.seek() | Posiciona el "cursor" del archivo hacia una posición dada. |
| File.position() | Retorna la posición actual del "cursor" del archivo. |
| File.size() | Retorna el tamaño del archivo (en bytes). |
| File.name() | Retorna el nombre del archivo/carpeta. |
| File.isDirectory() | Verifica si esta instancia realmente representa un directorio (carpeta) y no un archivo regular. |
| File.openNextFile() | Abre el siguiente archivo de la lista (válido si esta instancia representa un directorio/carpeta). |
| File.rewindDirectory() | Devuelve la iteración de archivos al comienzo (válido si esta instancia representa un directorio/carpeta). |
Nota: prácticamente ningún método funcionará si la instancia es "vacía" o representa un archivo/carpeta sin abrir.
Cómo agregar fecha y hora a los archivos
Todo archivo/fichero y directorio/carpeta tiene por atributos, además del nombre, la fecha y hora de creación, último acceso y última modificación (datos que se pueden mirar en las "propiedades" o "detalles" del elemento, en el explorador de archivos de tu PC). La librería por defecto no tiene definido cómo obtener dicha información; pero cuando es requerido, por defecto coloca el 01/01/2000 12:00:00 am aunque haya transcurrido un tiempo desde que el sistema ha arrancado.
Para definir la obtención de esos datos, primero debes crear una función con la siguiente "firma" (declaración):
void nombreFuncion(uint16_t* fecha, uint16_t* hora)
Quiere decir que dicha función DEBE retornar void y DEBE tener dos parámetros de tipo uint16_t*. El nombre no es importante.
En dicha función, programarás la obtención de la fecha y hora actualizados; que pueden provenir de un reloj generado por software, un reloj NTP o un RTC.
Luego, en el setup(), colocas esta línea para así otorgarle dicha definición a la librería:
SdFile::dateTimeCallback(nombreFuncion);
Advertencias
- Atento al uso de la SRAM, esta librería suele ser intensiva en ese recurso. Inicialmente consume alrededor de 700 bytes de este tipo de memoria.
- La tarjeta debe estar formateada en FAT16 o FAT32 con SDFormatter (NUNCA CON LOS UTILITARIOS DEL SISTEMA OPERATIVO), de lo contrario no funcionará con la librería o podría tener un bajo rendimiento.
Ejemplo 1
void obtenerFechaHora(uint16_t* fecha, uint16_t* hora) {
// Aquí llamas al reloj para que actualice los datos
*fecha = FAT_DATE(anio, mes, dia);
*hora = FAT_TIME(hora, minuto, segundo);
}
void setup() {
// Todas las demás inicializaciones
SdFile::dateTimeCallback(obtenerFechaHora);
}
void loop() {
// El resto del programa
}
Siendo anio una variable de tipo unsigned int, mientras que el resto de componentes son de tipo byte. El año se agrega con un valor que tenga los cuatro dígitos.
El rango de fecha y hora válido es del 01/01/1980 12:00:00 am al 31/12/2107 11:59:59 pm.
Una vez "adjuntada", esta función se utiliza de manera similar a como ocurre en las interrupciones: implícitamente cuando la librería la necesite.
La fecha/hora de creación se aplica únicamente al momento de crear un archivo/carpeta que antes no existía; la de acceso con el simple hecho de lograr abrirla; y la de modificación cuando se cierra un archivo regular que fue abierto para escritura, o cuando una subcarpeta adquiere o pierde contenido.
Ejemplo 2
Vea también
