1
00:00:00,180 --> 00:00:06,160
Hola, muy buenas. En esta práctica vamos a aprender a comunicar la placa de Arduino con el ordenador.

2
00:00:06,620 --> 00:00:13,279
Como bien sabemos, la información en los ordenadores se codifica en forma de unos y ceros y se agrupan formando palabras.

3
00:00:13,800 --> 00:00:21,760
De esta manera podemos tener palabras formadas por 8 bits, lo que conocemos como bytes, o palabras formadas por varios bytes.

4
00:00:21,760 --> 00:00:31,160
Por ejemplo, en Arduino, para los caracteres se emplean palabras de un solo byte, mientras que para los números enteros se emplean palabras de 2 bytes.

5
00:00:31,440 --> 00:00:38,740
Existen básicamente dos formas para que dos dispositivos se puedan enviar esta serie de bits de unos a otros.

6
00:00:38,979 --> 00:00:45,259
Una es mediante conexiones paralelas. En este caso, se tendría que llevar un cable por cada uno de los bits.

7
00:00:45,259 --> 00:00:57,759
La otra forma es la comunicación serie, de tal manera en la que con un único cable, o mejor dicho, un par de cables al menos, se van enviando bit a bit cada uno de los elementos que forman la palabra.

8
00:00:58,299 --> 00:01:02,079
Típicamente, en los ordenadores conviven las dos formas de comunicación.

9
00:01:02,600 --> 00:01:09,480
Ya sabemos que la comunicación que se utiliza entre la CPU y la memoria principal del ordenador es en paralelo.

10
00:01:09,480 --> 00:01:14,939
Por el bus de datos iría cada uno de los bits de una palabra de la memoria.

11
00:01:14,939 --> 00:01:23,739
Pero también existen otras conexiones donde la comunicación se realiza mediante puertos de tipo serie, como es el caso de los conectores USB.

12
00:01:24,280 --> 00:01:37,700
También nos podemos encontrar, por ejemplo, puertos paralelos, el típico en el que se conectaban antiguamente las impresoras, o puertos serie donde antiguamente se enganchaban, por ejemplo, los fases.

13
00:01:37,700 --> 00:01:47,200
Bien, si nos fijamos en nuestra placa de Arduino hay dos pines digitales, el 0 y el 1, que tienen las palabras RX y TX

14
00:01:47,200 --> 00:01:54,000
Estos dos pines se utilizan para la comunicación serie, donde RX será para recibir y TX para transmitir

15
00:01:54,000 --> 00:01:59,700
Pero además tenemos conectados esos dos pines con la conexión USB de la placa de Arduino

16
00:01:59,700 --> 00:02:04,879
Si nos fijamos en un conector de USB vamos a encontrar realmente cuatro cables

17
00:02:04,879 --> 00:02:10,560
Los dos exteriores se utilizan para alimentar la placa y los dos interiores para comunicación.

18
00:02:10,879 --> 00:02:17,000
Pues bien, nuestra placa de Arduino tiene estos dos pines, el 0 y el 1, conectados con el USB,

19
00:02:17,240 --> 00:02:23,300
de tal manera que podemos comunicarnos a través del USB con el ordenador, que es lo que vamos a hacer en esta práctica.

20
00:02:23,840 --> 00:02:30,599
Una cosa que tenemos que tener en cuenta cuando utilizamos estos dos pines es que no los podemos tener activos cuando cargamos un programa

21
00:02:30,599 --> 00:02:34,300
porque puede interferir con la comunicación con el ordenador.

22
00:02:34,879 --> 00:02:39,599
Bueno, pues vamos a ver cómo podemos utilizar esto que hemos dicho para comunicarnos con el ordenador.

23
00:02:39,599 --> 00:02:46,000
En la referencia de Arduino vamos a encontrar la clase Serial que va a tener una serie de métodos, es decir, funciones,

24
00:02:46,219 --> 00:02:50,840
que nos va a permitir la comunicación entre el ordenador y nuestra placa de Arduino.

25
00:02:51,159 --> 00:02:52,400
Pero vamos a verlo con un ejemplo.

26
00:02:52,860 --> 00:02:56,599
En el setup vamos a utilizar la función Begin de la clase Serial.

27
00:02:56,599 --> 00:03:05,300
Como la comunicación serie de Arduino es asíncrona, necesitamos decirle la cantidad de bits por segundo que vamos a enviar.

28
00:03:05,599 --> 00:03:08,639
Un valor típico sería el de 9600.

29
00:03:09,900 --> 00:03:16,259
Y tanto el transmisor como el receptor tienen que tener esta velocidad configurada porque si no, no funcionaría.

30
00:03:16,740 --> 00:03:20,560
A continuación vamos a crearnos un dato de tipo carácter.

31
00:03:21,020 --> 00:03:23,840
Char es el tipo de dato que se utiliza para los caracteres.

32
00:03:23,840 --> 00:03:30,719
Así pues, vamos a crearnos la variable letra y le vamos a asignar el valor de la letra b.

33
00:03:31,419 --> 00:03:35,680
Para asignar valores individuales de tipo carácter se utilizan las comillas simples.

34
00:03:36,060 --> 00:03:39,960
Y a continuación vamos a enviar este dato utilizando la clase serial.

35
00:03:41,080 --> 00:03:45,060
Serial.print letra.

36
00:03:45,060 --> 00:03:53,800
Y para no saturar de letras nuestra pantalla vamos a esperar un segundo cada vez que escribimos una letra.

37
00:03:53,840 --> 00:04:01,099
para ver en el ordenador la información que envía la placa, vamos a utilizar el monitor serie, que está aquí abajo.

38
00:04:01,520 --> 00:04:08,620
Entonces, ahora cuando ejecutemos, tenemos que ver que van a ir apareciendo segundo a segundo la información que estamos enviando.

39
00:04:08,620 --> 00:04:18,579
Ok, perfecto. Si queremos que estas letras aparezcan en líneas distintas, podemos utilizar el método println.

40
00:04:18,579 --> 00:04:20,339
Probemos de nuevo

41
00:04:20,339 --> 00:04:28,680
Bien, con esta técnica podemos enviar también cadenas de texto

42
00:04:28,680 --> 00:04:33,720
Para las cadenas de texto se suele emplear el tipo de datos string

43
00:04:33,720 --> 00:04:39,600
String en realidad es un objeto, pero se utiliza tanto que ya viene implementado dentro del lenguaje

44
00:04:39,600 --> 00:04:42,300
De esta forma vamos a crearnos la variable texto

45
00:04:42,300 --> 00:04:47,120
Y entre comillas dobles vamos a poner el texto que queremos enviar

46
00:04:47,120 --> 00:04:49,800
Por ejemplo, hola mundo

47
00:04:49,800 --> 00:04:51,360
Vamos a comentar esta línea de aquí

48
00:04:51,360 --> 00:04:53,939
y vamos a enviar este texto.

49
00:04:55,420 --> 00:04:58,540
Vamos a borrar lo que tenemos en el monitor serie con este botón

50
00:04:58,540 --> 00:05:00,779
y vamos a iniciar la simulación.

51
00:05:02,300 --> 00:05:06,839
Como vemos, cada segundo nos envía directamente la cadena de texto.

52
00:05:08,180 --> 00:05:12,379
Y por último, para completar esta parte, vamos a mandar un número.

53
00:05:12,680 --> 00:05:13,579
Nos creamos la variable.

54
00:05:14,480 --> 00:05:17,540
Fijaros que aquí no se emplea ni comillas simples ni comillas dobles.

55
00:05:17,540 --> 00:05:22,040
E igual que hicimos antes, comentamos esta línea y vamos a enviar el número.

56
00:05:26,329 --> 00:05:27,970
Bien, perfecto. Ahí lo vemos.

57
00:05:28,889 --> 00:05:35,230
Bien, ya hemos visto cómo podemos enviar información desde nuestra placa de Arduino al ordenador.

58
00:05:35,370 --> 00:05:39,810
Ahora vamos a ver cómo enviar información desde el ordenador a la placa de Arduino.

59
00:05:40,250 --> 00:05:46,509
Esto es muy útil porque nos va a permitir gobernar nuestro sistema mediante comandos que enviemos a través del ordenador.

60
00:05:46,910 --> 00:05:49,750
Y para hacer esto vamos a montar un sencillo circuito.

61
00:05:50,709 --> 00:06:12,069
Como siempre, vamos a utilizar nuestras conexiones, vamos a poner un LED, vamos a conectarlo a tierra, vamos a dar a la resistencia un valor de 250 ohmios y vamos a engancharla al pin 2.

62
00:06:12,709 --> 00:06:20,170
Bueno, lo que vamos a hacer con este programa es encender o apagar la bombilla en función de los comandos que nos manda el ordenador.

63
00:06:20,170 --> 00:06:29,310
Bueno, igual que antes tenemos que inicializar nuestro monitor, pero ahora en lugar de enviar letras vamos a recibirlas

64
00:06:29,310 --> 00:06:36,850
Vamos a borrar todo esto que ya no lo necesitamos y lo primero que haremos será preguntar si hay datos disponibles

65
00:06:36,850 --> 00:06:49,329
Para ello dentro de la estructura if utilizamos el método available que nos devuelve verdadero en caso de que haya datos disponibles y falso en caso contrario

66
00:06:49,329 --> 00:06:57,069
Y ahora vamos a utilizar el método read para asignar a nuestra variable el valor que se haya enviado desde el ordenador

67
00:06:57,069 --> 00:07:01,730
Es importante tener en cuenta que este método read lee un único byte

68
00:07:01,730 --> 00:07:03,370
Y ahora haremos lo siguiente

69
00:07:03,370 --> 00:07:08,350
Si la letra es una A, que no se nos olviden las notas iguales

70
00:07:08,350 --> 00:07:11,649
Vamos a encender el let con la función digitalWrite

71
00:07:11,649 --> 00:07:13,670
Donde tenemos que indicarle el pin

72
00:07:13,670 --> 00:07:16,029
Por cierto, se me ha olvidado configurar los pines

73
00:07:16,029 --> 00:07:32,750
Vamos a hacerlo, in pinLED igual a 12 y aquí en el setup tenemos que decir pinMode pinLED output y aquí utilizaremos pinLED y a nivel alto.

74
00:07:33,069 --> 00:07:36,470
Y si no, tendremos que escribir un nivel bajo.

75
00:07:37,009 --> 00:07:40,610
Vamos a borrar lo que había en el monitor serie y vamos a ver cómo funciona esto.

76
00:07:40,610 --> 00:07:45,949
Interesante, como inicializamos la variable letra con la letra B

77
00:07:45,949 --> 00:07:48,949
Hasta que se reciba la letra A desde el ordenador

78
00:07:48,949 --> 00:07:50,970
El LED va a estar apagado

79
00:07:50,970 --> 00:07:52,430
Vamos a comprobarlo

80
00:07:52,430 --> 00:07:54,769
Efectivamente, inicialmente está apagado

81
00:07:54,769 --> 00:07:57,209
Y si yo ahora envío una letra A

82
00:07:57,209 --> 00:07:59,050
Pues se enciende

83
00:07:59,050 --> 00:08:02,550
Bueno, aquí solo se ha encendido de forma muy rápida

84
00:08:02,550 --> 00:08:06,569
Porque hemos declarado la variable dentro del loop

85
00:08:06,569 --> 00:08:24,129
Entonces cada vez que se hace una vez el loop, pues inicializamos la letra AB, esto va a durar un A, el encendido, entonces si queremos que permanezca encendido más tiempo, tenemos que ponernos la variable aquí, es decir, tenemos que hacerla de tipo global.

86
00:08:24,129 --> 00:08:42,210
Y si ahora ejecutamos, vemos que aparece apagado, cuando le damos a la A se enciende y cuando mandemos cualquier otra letra, por ejemplo la B o da igual, una E, la que sea, cualquier otra, va a estar apagado.

87
00:08:42,450 --> 00:08:47,210
De nuevo, si damos a la A se enciende, cualquier otra letra se apaga.

88
00:08:47,769 --> 00:08:53,370
Bien, vemos como verdaderamente estamos gobernando nuestro sistema mediante órdenes del ordenador.

89
00:08:53,370 --> 00:09:02,190
Vamos a hacer un poquito más completo el programa para que, por ejemplo, cuando enviemos la letra P, el LED empieza a parpadear.

90
00:09:02,509 --> 00:09:09,070
Para ello vamos a utilizar la estructura else if, donde aquí vamos a decirle que si la letra es igual a P,

91
00:09:09,470 --> 00:09:18,870
pues lo que tenemos que hacer es encender, esperar, por ejemplo, 500 milisegundos, apagar y volver a esperar otros 500 milisegundos.

92
00:09:18,870 --> 00:09:25,549
Y por último vamos a decirle que si no, si se recibe cualquier otra cosa, vamos a apagar el LED.

93
00:09:25,649 --> 00:09:26,250
Vamos a probarlo.

94
00:09:26,970 --> 00:09:29,649
Bueno, inicialmente como vemos está apagado.

95
00:09:29,950 --> 00:09:34,970
Si ahora le damos una letra, por ejemplo la P, vemos que efectivamente parpadea.

96
00:09:35,549 --> 00:09:40,529
Si le damos la A, se queda encendido de forma fija.

97
00:09:40,950 --> 00:09:45,629
Y si le ponemos cualquier otra letra, por ejemplo la B, vamos a ver cómo el LED se apaga.

98
00:09:45,629 --> 00:09:49,789
De nuevo podemos darle a P, vemos que vuelve a parpadear.

99
00:09:50,350 --> 00:09:58,190
Bueno, vemos que efectivamente estamos gobernando nuestro sistema a través de órdenes que mandamos desde el ordenador.

100
00:09:58,629 --> 00:10:03,490
Bueno, ya hemos visto cómo podemos enviar letras de forma individual a la placa.

101
00:10:03,830 --> 00:10:06,629
Pero ¿qué pasa si queremos enviar una cadena de caracteres?

102
00:10:07,509 --> 00:10:12,490
En principio no se puede hacer de esta forma porque Read no va a leer carácter a carácter.

103
00:10:12,490 --> 00:10:19,470
Y eso puede suponer un problema. Para poder leer una cadena de caracteres, podemos hacerlo de la siguiente manera.

104
00:10:20,389 --> 00:10:26,889
Bueno, lo primero que vamos a hacer va a ser cambiar nuestra variable, que ahora va a ser de tipo string, y la vamos a llamar texto.

105
00:10:27,450 --> 00:10:36,470
Y por supuesto, ya no va entre comillas simples, sino entre comillas dobles, y le vamos a poner nada, porque nuestra variable texto la vamos a utilizar como un comando.

106
00:10:36,470 --> 00:10:58,269
Y ahora, donde aparece letra, ponemos nuestra variable texto y hacemos un rateString hasta until y vamos a ponerle aquí un carácter que es el retorno de carro. Se hace con la tecla invertida, que es al gr y arriba a la izquierda del teclado donde aparece la a y la o, esta pequeñita, vale, y n.

107
00:10:58,269 --> 00:11:12,110
Este es el carácter de retorno de carro. Por cierto, que podemos verlo en nuestra lista de caracteres acti, concretamente se corresponde con el valor decimal 13, sería este de aquí, el retorno de carro.

108
00:11:13,169 --> 00:11:22,769
Y este carácter viene asociado con la tecla intro de nuestro teclado, de tal manera que cuando escribimos un texto y le damos a retorno de carro, nos vamos a la siguiente línea, ¿verdad?

109
00:11:22,769 --> 00:11:48,470
Bien, pues ahora seguimos y decimos que nuestra variable texto cuando valga encender, y lo pongo entre comillas dobles, lo pondremos a nivel alto, y cuando nuestra variable texto valga parpadear, parpadearemos, y si no, bueno, vamos a completarlo, vamos a poner que si nuestra variable texto vale apagar, apagamos nuestro LED.

110
00:11:48,470 --> 00:11:50,929
Si enviamos cualquier otra cadena de texto

111
00:11:50,929 --> 00:11:52,090
No va a suceder nada

112
00:11:52,090 --> 00:11:53,149
Vamos a probarlo

113
00:11:53,149 --> 00:11:55,909
Me da un error

114
00:11:55,909 --> 00:11:57,649
Porque se me ha olvidado de que esto

115
00:11:57,649 --> 00:11:59,990
Tiene que ir entre comillas dobles

116
00:11:59,990 --> 00:12:01,070
No comillas simples

117
00:12:01,070 --> 00:12:02,570
Vale, vamos a ello

118
00:12:02,570 --> 00:12:05,389
Bien, pues ahora abrimos el monitor

119
00:12:05,389 --> 00:12:07,909
Y escribimos encender

120
00:12:07,909 --> 00:12:12,580
Y efectivamente

121
00:12:12,580 --> 00:12:13,639
Se ha encendido

122
00:12:13,639 --> 00:12:15,059
Vemos que tarda un poquito más

123
00:12:15,059 --> 00:12:17,039
Porque ya no estamos enviando solo un byte

124
00:12:17,039 --> 00:12:18,480
Sino varios bytes

125
00:12:18,480 --> 00:12:20,080
Varias letras

126
00:12:20,080 --> 00:12:21,620
Pero bueno, funciona

127
00:12:21,620 --> 00:12:23,740
Ahora le ponemos, por ejemplo, parpadear

128
00:12:23,740 --> 00:12:31,220
Y efectivamente nuestro LED comienza a parpadear

129
00:12:31,220 --> 00:12:33,440
Y si le escribimos apagar

130
00:12:33,440 --> 00:12:37,710
Pues se ha apagado

131
00:12:37,710 --> 00:12:38,669
Encender

132
00:12:38,669 --> 00:12:41,669
Se enciende de nuevo

133
00:12:41,669 --> 00:12:43,389
Y si escribimos cualquier otra cosa

134
00:12:43,389 --> 00:12:47,129
Pues vamos a ver que sigue exactamente igual que esta

135
00:12:47,129 --> 00:12:47,789
Que no cambia

136
00:12:47,789 --> 00:12:51,149
Bien, pues ya vemos la técnica que podemos utilizar

137
00:12:51,149 --> 00:12:53,990
Para enviar o recibir cadenas de texto

138
00:12:53,990 --> 00:13:11,230
Bien, y por último vamos a hacer lo mismo pero con los números, pero en este caso vamos a cambiar el programa de tal manera que el LED siempre va a estar parpadeando y lo que vamos a enviar es el tiempo de espera entre los parpadeos, es decir, vamos a controlar la velocidad de parpadeo de nuestro sistema.

139
00:13:11,230 --> 00:13:14,870
vamos a utilizar entonces una variable de tipo entero

140
00:13:14,870 --> 00:13:16,210
le vamos a llamar espera

141
00:13:16,210 --> 00:13:19,409
y vamos a ponerlo por defecto de 200 milisegundos

142
00:13:19,409 --> 00:13:24,070
a continuación vamos a cambiar esta variable por la nuestra de espera

143
00:13:24,070 --> 00:13:27,850
y vamos a utilizar el método partIn de la clase serial

144
00:13:27,850 --> 00:13:31,009
vamos a quitar todo esto que no necesitamos

145
00:13:31,009 --> 00:13:35,769
vamos a ordenar un poquito esta línea de aquí

146
00:13:35,769 --> 00:13:40,990
por cierto, para cambiar varias líneas de posición hacia la derecha o hacia la izquierda

147
00:13:40,990 --> 00:13:46,990
se seleccionan todas y se juega con el tabulador. Si yo doy una tabulación una vez seleccionado

148
00:13:46,990 --> 00:13:53,149
veo que se mueven hacia la derecha todas las líneas a la vez. Y si mantengo apretada

149
00:13:53,149 --> 00:13:59,210
la tecla de mayúsculas y doy al tabulador veo que viene hacia la izquierda todo el conjunto

150
00:13:59,210 --> 00:14:05,629
de líneas. Y todo esto nos sobra. Y ahora eso sí, aquí en lugar de un valor fijo le

151
00:14:05,629 --> 00:14:12,070
tenemos que decir nuestra variable espera. Vamos a probarlo. Vemos que está parpadeando

152
00:14:12,070 --> 00:14:17,009
con el valor inicial y si nosotros ahora ponemos por ejemplo 1000, vemos que parpadea más

153
00:14:17,009 --> 00:14:20,549
despacio. A la hora de introducir estos valores tenemos que tener cuidado porque si le ponemos

154
00:14:20,549 --> 00:14:26,289
un valor muy grande, por ejemplo 10000, vamos a ver que se enciende y se apaga cada 10 segundos

155
00:14:26,289 --> 00:14:31,830
y claro, cuando queramos mandar otro valor no va a ser inmediato porque hasta que nos

156
00:14:31,830 --> 00:14:50,009
ejecuta toda esta línea de aquí, pues no vamos a llegar a leer. Para paliar un poco este efecto, podemos limitar el valor de espera, de tal manera que decimos que si espera es mayor que, por ejemplo, un segundo, mil milisegundos, decimos que nuestra variable espera sea mil milisegundos.

157
00:14:50,009 --> 00:15:07,929
Esta es una técnica habitual para poner dentro de un rango de valores una variable, de tal manera que si ejecuto y pongo un valor, por ejemplo, de 10.000 como antes, vamos a ver que se limita al valor de un segundo solamente.

158
00:15:08,549 --> 00:15:18,210
No dejamos poner valores excesivamente grandes. Ahora, por ejemplo, ponemos un valor de 100 y vamos a ver cómo a continuación el LED parpadea de forma muy rápida.

159
00:15:18,210 --> 00:15:22,789
Bueno, pues ya hemos visto varias técnicas para poder comunicar la placa de Arduino con nuestro ordenador.

160
00:15:23,210 --> 00:15:27,289
Y estas técnicas van a ser parecidas para comunicarnos con otros dispositivos.

161
00:15:27,470 --> 00:15:35,610
Por ejemplo, podemos añadir un módulo de comunicación por Bluetooth a nuestra placa de Arduino de tal manera que podamos enviar y recibir comandos a través del móvil.

162
00:15:36,070 --> 00:15:37,389
Pero eso ya lo veremos más adelante.

163
00:15:37,870 --> 00:15:39,129
Venga, hasta la próxima práctica.