WEBVTT

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.