1
00:00:02,596 --> 00:00:08,596
[Orador 1]: Hola y bienvenidos de nuevo a este curso
MOOC sobre domótica, Arduino y consumo

2
00:00:08,596 --> 00:00:12,611
energético.

3
00:00:12,811 --> 00:00:16,979
En este tercer vídeo del segundo módulo
hablaremos sobre el último de los

4
00:00:16,979 --> 00:00:21,553
elementos, aparte de los sensores que ya
hemos visto, que conectaremos a nuestro

5
00:00:21,553 --> 00:00:24,448
microcontrolador Arduino, un lector de
tarjetas SD.

6
00:00:24,648 --> 00:00:30,154
Con él podremos guardar de forma
permanente los datos de nuestras medidas.

7
00:00:30,592 --> 00:00:35,619
Revisaremos en este vídeo cómo almacenar
de forma permanente datos en Arduino.

8
00:00:35,819 --> 00:00:41,380
Hablaremos sobre el módulo lector para
tarjetas microSD, veremos sus operaciones

9
00:00:41,380 --> 00:00:46,541
básicas de manejo y un ejemplo para
guardar ficheros CSV en estas tarjetas

10
00:00:46,541 --> 00:00:47,836
usando Arduino.

11
00:00:48,036 --> 00:00:53,758
Todas las placas Arduino incluyen una
pequeña memoria persistente de tipo ROM

12
00:00:53,758 --> 00:00:57,881
programable que se puede borrar de forma
electrónica.

13
00:00:58,081 --> 00:01:03,847
permite almacenar de forma permanente
datos, configuraciones e incluso variables

14
00:01:03,847 --> 00:01:08,014
de sketch que queremos utilizar en
diferentes programas.

15
00:01:08,857 --> 00:01:14,564
El problema es que la capacidad de esta
memoria es muy escasa, apenas de un

16
00:01:14,564 --> 00:01:20,139
kilobyte, en el más grande de los casos
entre Arduino Mega y Arduino Uno.

17
00:01:20,339 --> 00:01:25,156
Por supuesto, esos valores pueden
expandirse mediante memorias externas,

18
00:01:25,156 --> 00:01:30,573
pero es una operación muy compleja que
rara vez merece la pena en los sistemas de

19
00:01:30,573 --> 00:01:32,457
bajo coste de tipo Arduino.

20
00:01:33,417 --> 00:01:38,674
Por otro lado, el manejo de estas memorias
no es nada sencillo, requiere realizar

21
00:01:38,674 --> 00:01:43,997
programación a bajo nivel, con control de
direcciones de memoria, con escritura de

22
00:01:43,997 --> 00:01:49,321
datos específica en forma binaria, todo
ello mediante decisiones y estrategias del

23
00:01:49,321 --> 00:01:54,250
nivel de programador, por lo que en
general escapa del nivel de programación

24
00:01:54,250 --> 00:01:55,238
de Arduino.

25
00:01:56,738 --> 00:02:02,698
Como solución, existe una librería, la
librería EEPROM.h, en la que existen una

26
00:02:02,698 --> 00:02:06,792
serie de funciones que nos simplifican ese
trabajo.

27
00:02:06,992 --> 00:02:12,290
Las funciones read y write permiten
manejar direcciones, formatos binarios, de

28
00:02:12,290 --> 00:02:13,722
forma más sencilla.

29
00:02:13,922 --> 00:02:18,729
Aún así, y a pesar de ello, es una tarea
relativamente compleja.

30
00:02:18,929 --> 00:02:23,880
Por ello, a lo largo de los años han
aparecido otros mecanismos mucho más

31
00:02:23,880 --> 00:02:27,098
sencillos de manejo y de mucha mayor
capacidad.

32
00:02:29,240 --> 00:02:33,800
Por su alta disponibilidad actual, su
capacidad y su pequeño tamaño, las

33
00:02:33,800 --> 00:02:38,681
memorias microSD son quizá el formato
preferido para almacenar datos de forma

34
00:02:38,681 --> 00:02:40,159
persistente en Arduino.

35
00:02:40,382 --> 00:02:46,326
Existe en este tipo de plataformas un
lector para poder conectar una tarjeta

36
00:02:46,326 --> 00:02:49,137
microSD al microcontrolador.

37
00:02:50,047 --> 00:02:54,615
Tenemos en la pantalla este tipo de
lectores de tamaño muy reducido que

38
00:02:54,615 --> 00:02:59,510
cuentan con una librería totalmente
integrada en el software Arduino y en el

39
00:02:59,510 --> 00:03:03,948
entorno Arduino IDE, lo cual simplifica
muchísimo su uso y su manejo.

40
00:03:04,148 --> 00:03:08,726
La mayoría de estos modelos además ya
incluyen todas las resistencias de pull-up

41
00:03:08,726 --> 00:03:12,841
necesarias y todos los montajes
electrónicos precisos, de tal manera que

42
00:03:12,841 --> 00:03:17,477
simplemente es necesario conectar punto a
punto con cables las salidas y entradas

43
00:03:17,477 --> 00:03:18,477
del lector

44
00:03:18,430 --> 00:03:22,132
con las salidas y entradas del
microcontrolador.

45
00:03:23,996 --> 00:03:28,819
En conclusión, es posible realizar una
conexión directa de los siguientes

46
00:03:28,819 --> 00:03:29,842
terminales.

47
00:03:30,042 --> 00:03:34,828
Alimentación, se alimentará a 3,3 o 5
voltios dependiendo del modelo.

48
00:03:35,028 --> 00:03:40,093
Tierra, normalmente indicado con las
siglas GND por su nombre en inglés.

49
00:03:40,293 --> 00:03:45,514
Y finalmente los cuatro terminales propios
del puerto SPI con el que podemos

50
00:03:45,514 --> 00:03:49,802
comunicar datos de la tarjeta al
microcontrolador y viceversa.

51
00:03:50,729 --> 00:03:55,392
SPI, por sus siglas en inglés Serial
Peripheral Interface, permite comunicar un

52
00:03:55,392 --> 00:03:59,457
dispositivo maestro con varios
dispositivos esclavos, pero siempre de

53
00:03:59,457 --> 00:04:00,448
forma síncrona.

54
00:04:00,648 --> 00:04:05,621
Al contrario que vimos los puertos serie,
los puertos UART, en los cuales se podía

55
00:04:05,621 --> 00:04:07,218
hacer de manera asíncrona.

56
00:04:07,418 --> 00:04:12,839
Siempre que un dispositivo SPI se conecta
con un Arduino, es necesario incluir la

57
00:04:12,839 --> 00:04:13,928
librería SPI.h.

58
00:04:14,128 --> 00:04:20,128
Por tanto, a pesar de incluir la librería
SD.h, en programas que necesiten la

59
00:04:20,128 --> 00:04:26,944
tarjeta SD con este tipo de lectores,
también debe incluir la librería SPI.h.

60
00:04:27,483 --> 00:04:31,735
En concreto los cuatro puertos, los cuatro
terminales SPI son los siguientes.

61
00:04:31,935 --> 00:04:36,573
Chip Select, usualmente nombrado como CS,
permite seleccionar libremente el

62
00:04:36,573 --> 00:04:41,462
dispositivo de entre todos los SPI que
están conectados al microcontrolador que

63
00:04:41,462 --> 00:04:45,474
se desea activar y con el que se va a
establecer la comunicación.

64
00:04:45,674 --> 00:04:51,318
Pin MOSI, es el pin de datos que comunica
el maestro con el esclavo, en esa

65
00:04:51,318 --> 00:04:53,029
dirección.

66
00:04:53,229 --> 00:04:57,886
El pin MOSI es específico de cada placa
Arduino, no vale cualquier pin, no se

67
00:04:57,886 --> 00:05:02,727
puede configurar, necesita un soporte
hardware y por lo tanto es uno específico.

68
00:05:02,927 --> 00:05:08,355
Por ejemplo, en Arduino Nano, en Arduino
Uno es el pin 11.

69
00:05:08,894 --> 00:05:13,599
Pin MISO es el pin de comunicación en
sentido contrario, desde el dispositivo

70
00:05:13,599 --> 00:05:18,120
esclavo, en este caso el lector de
tarjetas SD, al dispositivo maestro, en

71
00:05:18,120 --> 00:05:20,473
este caso el microcontrolador Arduino.

72
00:05:20,673 --> 00:05:25,581
El pin MISO también, al igual que MOSI, es
concreto de cada placa y hay que buscarlo

73
00:05:25,581 --> 00:05:26,723
en los mapas de pines.

74
00:05:26,923 --> 00:05:30,986
En Arduino Nano y en Arduino Uno es el pin
12.

75
00:05:31,186 --> 00:05:35,714
Finalmente, puesto que la comunicación,
como hemos dicho, es síncrona, existe una

76
00:05:35,714 --> 00:05:38,318
señal de reloj habitualmente nombrada como
SCK.

77
00:05:38,518 --> 00:05:43,248
Este pin envía el reloj siempre desde el
dispositivo maestro al dispositivo

78
00:05:43,248 --> 00:05:44,207
esclavo.

79
00:05:44,407 --> 00:05:48,474
Una vez más, el pin de reloj es también
concreto de cada placa.

80
00:05:48,674 --> 00:05:53,941
En Arduino Nano I1, que son los
dispositivos que vamos a utilizar en las

81
00:05:53,941 --> 00:05:55,943
medidas, es el pin 13.

82
00:05:58,000 --> 00:06:04,000
Para iniciar la operación de guardar datos
en un módulo SD simplemente debemos en la

83
00:06:04,000 --> 00:06:10,000
rutina de configuración añadir la
instrucción SD.begin indicando el pin

84
00:06:10,000 --> 00:06:16,000
digital que vamos a utilizar como chip
select, sea el 4 por ejemplo en nuestro

85
00:06:16,000 --> 00:06:20,580
caso o sea cualquier otro que podáis
seleccionar.

86
00:06:21,845 --> 00:06:27,044
Para comprobar si un nombre de archivo ya
existe en la tarjeta SD y por tanto no

87
00:06:27,044 --> 00:06:32,507
sobreescribirlo y borrar su contenido, se
puede utilizar la función Exits, indicando

88
00:06:32,507 --> 00:06:37,640
como argumento el nombre del archivo en
formato string, cadena de caracteres en

89
00:06:37,640 --> 00:06:38,628
español.

90
00:06:38,828 --> 00:06:44,032
Para manejar ficheros desde Arduino
podemos utilizar el formato de datos File,

91
00:06:44,032 --> 00:06:49,370
que es un objeto con funciones y métodos
propios para escribir, leer y comprobar

92
00:06:49,370 --> 00:06:51,242
diferentes características.

93
00:06:51,848 --> 00:06:57,848
Por ejemplo, en este trozo de código que
tenemos aquí, podemos ver cómo se utiliza

94
00:06:57,848 --> 00:07:03,848
la función open de la tarjeta SD para
crear un archivo con el nombre indicado y

95
00:07:03,848 --> 00:07:09,848
en formato tanto lectura como escritura,
lo cual lo tenemos por el file barra baja

96
00:07:09,848 --> 00:07:13,029
write del segundo argumento.

97
00:07:13,229 --> 00:07:18,928
Podemos utilizar la lectura con read, como
se puede ver, podemos utilizar println

98
00:07:18,928 --> 00:07:24,627
igual que si fuese un puerto serie para
escribir y finalmente siempre tenemos que

99
00:07:24,627 --> 00:07:29,194
cerrar el fichero con.close para evitar
que este quede ilegible.

100
00:07:31,032 --> 00:07:36,178
Finalmente, con todo lo visto, el código
quedaría como se puede ver a continuación.

101
00:07:36,378 --> 00:07:42,014
Incluimos las dos librerías que hemos
hablado, SPI y SD, declaramos un objeto

102
00:07:42,014 --> 00:07:47,384
file sobre el que realizaremos las
operaciones, ponemos el begin sobre el

103
00:07:47,384 --> 00:07:53,384
chip select, en este caso como he dicho el
pin 4, comprobamos si existe un fichero,

104
00:07:53,384 --> 00:07:55,487
en este caso datos.csv,

105
00:07:55,687 --> 00:08:00,522
Si no existe realizamos la apertura y
creación de este fichero en formato

106
00:08:00,522 --> 00:08:05,891
lectura-escritura y pasamos utilizando la
función println a escribir las medidas,

107
00:08:05,891 --> 00:08:09,327
primero el tiempo y después la de los tres
sensores.

108
00:08:09,527 --> 00:08:14,471
Finalmente cerramos el fichero, el
programa termina y tendríamos guardadas

109
00:08:14,471 --> 00:08:16,815
las medidas en nuestra tarjeta SD.

110
00:08:19,818 --> 00:08:25,389
En el bucle principal lo que haríamos
sería en cada ciclo de medida aumentar el

111
00:08:25,389 --> 00:08:30,627
número de filas para añadir en cada
instante las medidas de los diferentes

112
00:08:30,627 --> 00:08:31,999
sensores.

113
00:08:32,199 --> 00:08:38,199
En este caso como podemos ver en los pines
A0, A1 y A2 hemos conectado los sensores y

114
00:08:38,199 --> 00:08:42,476
en cada bucle iremos añadiendo una nueva
línea.

115
00:08:42,676 --> 00:08:47,124
Tenemos un delay para evitar que el
archivo crezca de forma descontrolada

116
00:08:47,324 --> 00:08:52,483
y simplemente cuando deseásemos parar la
ejecución tendríamos que desconectar

117
00:08:52,483 --> 00:08:53,577
Arduino.

118
00:08:53,777 --> 00:08:59,536
Es posible por supuesto incluir algún otro
tipo de mecanismo como ya veremos en el

119
00:08:59,536 --> 00:09:02,316
módulo 4 cuando realicemos las medidas.

120
00:09:02,516 --> 00:09:03,257
Muchas gracias.