1
00:00:05,370 --> 00:00:11,430
Bienvenidos a un capítulo más de este curso y en este caso ya arrancamos con programación básica en

2
00:00:11,430 --> 00:00:12,750
C++.

3
00:00:12,750 --> 00:00:14,850
Empezaremos viendo variables

4
00:00:17,360 --> 00:00:27,330
como primera medida ya abri la idea de Arduino como Ben pero teniendo miedo a que estemos en situaciones

5
00:00:27,330 --> 00:00:33,340
diferentes y a ustedes les haya arrancado con otro archivo para emparejar y que vayamos al unísono.

6
00:00:33,390 --> 00:00:40,440
Vamos archivo nuevo y van a ver que se abre otra ventana y seguramente va a estar vacía o va a estar

7
00:00:40,440 --> 00:00:43,650
como está entonces la anterior o la voy a cerrar.

8
00:00:43,650 --> 00:00:51,140
No voy a guardar los cambios y vamos a trabajar con esto variables tan útiles tan usadas.

9
00:00:51,300 --> 00:00:59,100
Las variables son un pedacito de memoria RAM que vamos a reservar de nuestro microcontrolador para guardar

10
00:00:59,310 --> 00:01:02,640
valores de diferente tipo.

11
00:01:03,210 --> 00:01:04,140
Se acuerdan no.

12
00:01:04,260 --> 00:01:10,050
La memoria RAM es aquella que cuando se apaga el Arduino cuando le corto la energía se borra la memoria

13
00:01:10,050 --> 00:01:15,290
RAM que vamos a reservar nos va a servir para llevar por ejemplo cuentas como les di el ejemplo voy

14
00:01:15,280 --> 00:01:18,740
a ir contando por qué no una serie de eventos.

15
00:01:19,410 --> 00:01:25,770
Supongamos que estamos contando personas que pasan por un sensor en la cuenta de personas la UIR llevando

16
00:01:25,800 --> 00:01:31,020
en una memoria RAM cada vez que el sensor detecta el paso de alguien a esa variable la voy a incrementar

17
00:01:31,020 --> 00:01:31,640
en uno.

18
00:01:31,710 --> 00:01:37,380
Entonces voy a ir contando uno dos tres y me voy a permitir en todo caso llegado determinado valor tomar

19
00:01:37,380 --> 00:01:37,860
una acción.

20
00:01:37,860 --> 00:01:45,360
Supongamos quiero cerrar una barrera cuando pasen 10 personas uno o dos tres y cuando llegue a 10 efectuó

21
00:01:45,360 --> 00:01:52,950
la acción de cerrar la barrera pero tengo que tener presente que esa cuenta que voy a ir llevando cuando

22
00:01:52,950 --> 00:01:58,530
se apague el Arduino se va a borrar cuando lo vuelvo a enchufar o arrancar en cero como les dije.

23
00:01:58,530 --> 00:02:02,830
Hay distintos tipos de variables según el dato que van a almacenar.

24
00:02:03,030 --> 00:02:09,150
Entonces vamos a ver cómo se declaran las variables de acuerdo al tipo de datos que almacenan.

25
00:02:09,180 --> 00:02:12,920
La más básica es el número entero.

26
00:02:12,930 --> 00:02:19,170
Cuando subí a guardar un número entero en esta variable para declarar variables enteras vi utilizar

27
00:02:19,260 --> 00:02:20,980
la palabra reservada Int.

28
00:02:21,000 --> 00:02:23,090
Qué quiere decir palabras reservadas.

29
00:02:23,100 --> 00:02:29,910
Quiero decir que son denominadores propios del lenguaje C que sólo se van a poder usar para declarar

30
00:02:29,910 --> 00:02:31,170
una variable entera.

31
00:02:31,170 --> 00:02:36,870
Yo no voy a poder usar la palabra INT para otra cosa que no sea esto.

32
00:02:36,900 --> 00:02:41,390
De hecho si lo hago el sistema no me lo va a permitir.

33
00:02:41,670 --> 00:02:48,330
Luego yo le voy a dar un nombre a esa variable ese nombre puede ser cualquier cosa puede ser una letra

34
00:02:48,450 --> 00:02:56,510
puede ser una palabra la palabra número desde luego que yo les voy a recomendar que siempre elijamos

35
00:02:58,360 --> 00:03:03,910
nombres de variable acordes a lo que van a guardar es cierto.

36
00:03:03,910 --> 00:03:10,930
Como regla general la mayoría de los programadores utilizamos variables en inglés pero cuando estamos

37
00:03:10,930 --> 00:03:14,950
aprendiendo se da un fenómeno que a veces no es tenido en cuenta.

38
00:03:14,950 --> 00:03:22,320
Si yo al nombre de la variable le pongo nombre en inglés vamos a poner nombre

39
00:03:26,680 --> 00:03:33,960
nosotros que somos hispanoparlantes tendemos a confundir que porque esté en inglés es una palabra reservada

40
00:03:34,750 --> 00:03:38,090
entonces vamos a tratar ahora.

41
00:03:38,240 --> 00:03:44,530
Y les aclaro no es lo que se suele usar de utilizar nombres de variables en español cuando ya tengamos

42
00:03:44,530 --> 00:03:51,610
práctica lo mejor va a ser que utilicemos nombres de variables en inglés.

43
00:03:51,610 --> 00:03:56,050
Supongamos como les dije recién si yo utilizo como nombre de Variable

44
00:03:58,870 --> 00:04:09,340
Counter People voy a tender a que ustedes se confundan de qué está mal escrito.

45
00:04:09,370 --> 00:04:14,610
Esto es una palabra reservada es un comando de C++ o es el nombre de la variable y yo me quiero asegurar

46
00:04:14,670 --> 00:04:22,230
que ustedes entiendan de qué nombre lo decido yo como quiera entonces yo puedo poner personas contadas

47
00:04:25,100 --> 00:04:32,780
listo ahí se declare una variable ya reservé un pedacito de memoria para guardar la cantidad de personas

48
00:04:32,780 --> 00:04:35,090
contadas y es un entero.

49
00:04:35,150 --> 00:04:39,350
Qué tamaño tiene el pedacito de memoria que reserve vamos a verlo.

50
00:04:39,350 --> 00:04:44,720
Déjenme recordarles que acá nos estamos preparando para ser todo terreno.

51
00:04:44,720 --> 00:04:53,540
No va a servir de mucho que venga y les muestre acá en la página de Arduino están todas las definiciones

52
00:04:53,630 --> 00:05:01,050
y como ven qué sentido tiene que les diga lo correcto es cierto una variable de tipo entero puede almacenar

53
00:05:01,050 --> 00:05:12,460
datos tanto negativos como positivos que van desde al menos 32 mil 768 hasta el 32 mil 767 lo que quiero

54
00:05:12,460 --> 00:05:22,360
decirles es que tienen a mano la posibilidad de buscar cuanta duda tengan no siempre nos vamos a acordar

55
00:05:22,420 --> 00:05:24,060
de todo entonces.

56
00:05:24,340 --> 00:05:32,240
De hecho yo para contarles a ustedes con exactitud cuántos son los valores máximos de cada tipo de variable.

57
00:05:32,410 --> 00:05:42,280
Lo que hice fue buscarlo simple Miren puse Arduino int y tengo la respuesta.

58
00:05:42,530 --> 00:05:48,000
Otra característica de cuando declaramos la variable es que al mismo tiempo que la declaró también le

59
00:05:48,000 --> 00:05:55,010
puedo asignar un valor ya de entrada puede valer cero ya de entrada puede valer 10 o simplemente la

60
00:05:55,010 --> 00:06:01,080
declaró y todavía no tiene un valor volviendo de la referencia de Arduino podemos ver que el número

61
00:06:01,080 --> 00:06:07,290
máximo está limitado por el tipo de arquitectura del microcontrolador que en este caso es de 16 bits

62
00:06:08,460 --> 00:06:17,660
conformados por dos bits es por esto que podemos tener este margen cuando declaramos enteros.

63
00:06:17,660 --> 00:06:25,860
Pero fíjense algo yo puedo utilizar dentro de las variables enteros un subtipo vamos a decirles que

64
00:06:25,860 --> 00:06:26,460
son las

65
00:06:30,140 --> 00:06:31,540
sin signo.

66
00:06:31,910 --> 00:06:41,310
De esta manera sólo voy a tener valores positivos cuando utilizo variables sin signo se duplica el valor

67
00:06:41,310 --> 00:06:42,180
máximo.

68
00:06:42,180 --> 00:06:53,150
Vamos a poder tener más de 65000 valores posibles en una Balet en una variable entero sin signo.

69
00:06:53,270 --> 00:07:00,160
Bueno repasando tipos de variables para almacenar números.

70
00:07:00,220 --> 00:07:08,870
Podemos ir a los de tipo float en este caso son variables de tipo decimal o punto flotante.

71
00:07:09,160 --> 00:07:18,510
Igual vamos a poner un ejemplo peso alumno

72
00:07:22,230 --> 00:07:30,870
en este caso le puedo asignar un valor en el momento en el que le declaró por ejemplo 56.

73
00:07:31,170 --> 00:07:32,800
Punto 8

74
00:07:37,660 --> 00:07:39,810
qué cantidad de valores puedo guardar acá.

75
00:07:39,810 --> 00:07:50,570
Cuál es el número máximo nosotros somos todoterreno entonces vamos a Arduino luego me tengo que acostumbrar

76
00:07:50,660 --> 00:07:53,000
a buscar información

77
00:07:56,330 --> 00:08:03,550
en línea y como verán en los float tenemos hasta seis o siete decimales.

78
00:08:03,550 --> 00:08:10,240
En cuanto a precisión otro tipo de variable que vamos a poder declarar para almacenar números son los

79
00:08:10,240 --> 00:08:22,080
de tipo Longa a esta le voy a llamar número largo o mejor número grande va a ser igual.

80
00:08:22,980 --> 00:08:24,260
Cuál es el tamaño máximo.

81
00:08:24,270 --> 00:08:36,150
Ya busqué dos mil 147 millones 483 1647 positivos o si no lo mismo en negativos.

82
00:08:36,150 --> 00:08:42,660
Por supuesto que si utilizo la versión sin signo voy a duplicar el tamaño máximo de la variable

83
00:08:45,000 --> 00:08:55,940
entonces me gustaría hacerles una pregunta podría utilizar yo una valla una variable Longa llamada vamos

84
00:08:55,940 --> 00:08:58,140
a poner un nombre a ver años.

85
00:09:01,230 --> 00:09:06,480
alumno y la voy a usar para almacenar la edad de alguno de mis alumnos.

86
00:09:07,820 --> 00:09:17,730
Igual tengo un alumno suponemos de 30 años funcionaría esta variable guardaría estos 30 en una variable

87
00:09:17,730 --> 00:09:19,080
de tipo long.

88
00:09:19,110 --> 00:09:21,510
Claro que sí sería eficiente.

89
00:09:21,630 --> 00:09:30,250
Claro que no porque estoy reservando un espacio de memoria capaz de alojar semejante número para guardar

90
00:09:30,250 --> 00:09:41,950
un número que jamás superará los 80 90 100 años entonces esto es una ventaja de este lenguaje que es

91
00:09:41,950 --> 00:09:44,650
un lenguaje fuertemente tipado.

92
00:09:44,650 --> 00:09:51,940
Este es una manera técnica de describir esto y es que una vez que yo declaro un tipo de variable no

93
00:09:51,940 --> 00:09:59,440
la voy a poder pasar a otro tipo o sea en un en un long no voy a poder guardar nunca un float me va

94
00:09:59,440 --> 00:10:01,810
a dar error no me va a dejar.

95
00:10:01,820 --> 00:10:09,240
Asimismo si puedo utilizar un long para guardar un número entero pero estoy desperdiciando memoria lo

96
00:10:09,240 --> 00:10:19,650
correcto o lo óptimo o lo eficiente sería utilizar un Hind años igual a 30 porque ya sabemos que los

97
00:10:19,650 --> 00:10:22,290
Hint no guardan números tan grandes.

98
00:10:22,290 --> 00:10:25,200
No estoy malgastando memoria en definitiva.

99
00:10:25,410 --> 00:10:34,350
Pero sigamos porque hay muchos tipos de variables entre ellas tenemos el del tipo Jar Jar Char es simplemente

100
00:10:34,740 --> 00:10:43,110
un bait o lo que puede entenderse de otra manera un carácter es para guardar se vamos a probar y a crear

101
00:10:43,110 --> 00:10:52,010
un carácter que se va a llamar primera letra ahí lo estoy declarando o puedo declararlo y al mismo tiempo

102
00:10:52,330 --> 00:11:01,130
le voy a asignar un valor por lo general C el valor va a ir entre comillas simples y la letra de la

103
00:11:01,130 --> 00:11:03,650
primera letra del nombre es la P.

104
00:11:03,650 --> 00:11:10,570
Aquí puedo poner cualquier letra o número pero aunque ponga un número este número que estoy poniendo

105
00:11:10,570 --> 00:11:16,760
acá por ejemplo un 4 no va a ser interpretado matemáticamente sino como un carácter.

106
00:11:16,960 --> 00:11:24,150
O sea que a este años a futuro le voy a poder sumar otro número pero a este carácter jamás le voy a

107
00:11:24,150 --> 00:11:28,880
poder sumar otro número porque es interpretado como una letra como un carácter no como un número.

108
00:11:30,760 --> 00:11:38,770
Recuerden los Char sólo pueden almacenar una sola letra más adelante vamos a ver que hay un tipo de

109
00:11:38,770 --> 00:11:45,910
variable que son los Arráiz que pueden ser combinados con cualquiera de estas variables y a grandes

110
00:11:45,910 --> 00:11:56,620
rasgos una Ray es una pila o una una cantidad determinada de variables es una variable de variables

111
00:11:58,110 --> 00:12:07,170
entonces cuando quiero grabar o almacenar en una variable una oración lo que se hace es una raíz de

112
00:12:07,210 --> 00:12:14,460
charts o sea son muchos charts unos al lado del otro por así entenderlo pero de momento vamos a dejar

113
00:12:14,460 --> 00:12:21,060
los Arráiz para más adelante y ahora vamos a ver una clase clase es el término pero lo vamos a usar

114
00:12:21,480 --> 00:12:27,880
como si fueran variables si o si necesitamos avanzar un poco más para entrar en detalle.

115
00:12:27,990 --> 00:12:36,580
Así que por ahora le vamos a decir variables pero a ciencia cierta es una clase que son los strings

116
00:12:36,640 --> 00:12:48,350
empieza con mayúscula string vamos a decir por ejemplo oración hoy tengo una string cómo se llama esta

117
00:12:48,350 --> 00:12:55,460
variable oración y quiero almacenar oraciones como todas variables le voy a poder dar un valor al momento

118
00:12:55,460 --> 00:12:59,990
de definir la escala estoy creando y ya no más le puedo pasar entre comillas dobles

119
00:13:06,400 --> 00:13:07,330
bienvenidos

120
00:13:09,990 --> 00:13:13,940
puedo crear otro otro string saludo

121
00:13:18,640 --> 00:13:20,940
Hola tía

122
00:13:24,240 --> 00:13:28,920
y por último vamos a ver el tipo de variable.

123
00:13:28,970 --> 00:13:36,410
Juliana se declara de la siguiente manera con la palabra reservada vull le vamos a poner un nombre y

124
00:13:36,410 --> 00:13:43,730
de nombre le vamos a poner por ejemplo activado activado por qué lo hago.

125
00:13:43,730 --> 00:13:49,550
Pregunta porque de ahí viene yo también puedo darle un valor en el momento de declarar la variable y

126
00:13:49,550 --> 00:13:54,020
puede ser tú o puedes ser fouls.

127
00:13:54,290 --> 00:13:55,120
Esto qué quiere decir.

128
00:13:55,130 --> 00:14:06,290
Las variables Pulianas sólo pueden contener dos valores o verdadero o falso o uno o cero o alto o bajo

129
00:14:07,350 --> 00:14:12,450
en definitiva este tipo de variables las vamos a usar cuando necesitemos realizar acciones que sólo

130
00:14:12,450 --> 00:14:18,780
tienen dos posibilidades o cuando tengamos que registrar datos que solo tienen dos caminos.

131
00:14:18,780 --> 00:14:25,440
Por ejemplo yo necesito saber el estado de un LED activado sí o no.

132
00:14:25,560 --> 00:14:32,970
Entonces consultando la variable activado puedo saber si se está encendido o apagado pero como esta

133
00:14:32,970 --> 00:14:40,070
es una variable que para explicarla o para que la entiendan necesitamos avanzar un poquito más.

134
00:14:40,200 --> 00:14:46,780
Me remito a decir que existe ahí está y muy pronto vamos a avanzar en ello y qué mejor que redondear

135
00:14:46,780 --> 00:14:52,540
este capítulo de variables con algún ejercicio y con algo que sea un poco más entretenido la verdad.

136
00:14:52,900 --> 00:14:56,530
Entonces vamos a hacer lo siguiente

137
00:15:02,860 --> 00:15:07,690
Vamos a declarar una variable y vamos a llamarla número

138
00:15:10,570 --> 00:15:21,470
mejor cuenta igual a cero arranca valiendo cero y acabemos vemos que tenemos dos pedazos de código bien

139
00:15:21,470 --> 00:15:29,500
definidos más adelante vamos a ver que en realidad estas son funciones pero por ahora vamos a decir

140
00:15:29,500 --> 00:15:35,940
que tenemos una parte de código llamada ZetaP y el ZetaP es lo que vamos a encontrar dentro de estas

141
00:15:35,940 --> 00:15:37,320
dos llaves.

142
00:15:37,320 --> 00:15:43,260
Fíjense que si me paro en esta llave el Ideame es como que me marca la de abajo diciéndome que lo que

143
00:15:43,260 --> 00:15:49,940
está acá adentro va a ser el ZetaP y tenemos otra que se llama Luv van a ser las líneas de código que

144
00:15:49,940 --> 00:15:51,670
yo ponga en esta parte

145
00:15:54,730 --> 00:16:01,110
si bien vamos a profundizar a grandes rasgos les puedo decir que todas las líneas de código que yo escriba

146
00:16:01,120 --> 00:16:07,420
en el ZetaP se ejecutarán una sola vez o sea apenas arranque en nuestra placa y las que pongan en el

147
00:16:07,430 --> 00:16:14,940
lugar se van a repetir continuamente sé que ahora puede parecer algo confuso pero más adelante vamos

148
00:16:14,940 --> 00:16:15,190
a hacer.

149
00:16:15,240 --> 00:16:23,430
Vamos a ir aclarando estos temas no se preocupen como les dije lo que pongamos en el club se va a repetir

150
00:16:23,520 --> 00:16:24,450
indefinidamente.

151
00:16:24,900 --> 00:16:37,900
Entonces vamos a agarrar y poner que cuenta es igual la cuenta +1 en definitiva cada vez que se ejecuta

152
00:16:37,900 --> 00:16:43,780
esta línea de código que como les advertí se va a ejecutar para siempre indefinidamente una y otra vez

153
00:16:43,900 --> 00:16:48,090
lo que hace es tomar el valor que tiene cuenta con cuanto arranca con cero.

154
00:16:48,460 --> 00:16:57,120
Digo que es igual a cero más uno en este paso cuenta ya vale uno y en el próximo al sumarle otra vez

155
00:16:57,120 --> 00:17:10,070
uno va a valer 2 y 3 y 4 y 5 con controles de archivo grabar voy a grabar este programa aunque no lo

156
00:17:10,070 --> 00:17:16,580
crean en nuestro primer programa y a diferencia de muchos no es el prender y apagar un LED porque necesitamos

157
00:17:16,580 --> 00:17:17,810
aprender a programar primero.

158
00:17:18,260 --> 00:17:20,780
Entonces quería arrancar con las variables

159
00:17:23,400 --> 00:17:26,670
vamos a darle un nombre le vamos a ver variables

160
00:17:29,330 --> 00:17:32,810
y se nos va a guardar en la carpeta Arduino

161
00:17:37,630 --> 00:17:46,780
le doy grabar y como ven ya nuestro programa tiene nombre y esto hace que automáticamente se nos cree

162
00:17:46,840 --> 00:17:53,010
dentro de la carpeta Arduino una carpeta llamada variables y en su interior.

163
00:17:53,140 --> 00:17:57,240
El programa en cuestión denominado variables punto y no

164
00:18:00,740 --> 00:18:02,180
llegó el momento de grabarlo.

165
00:18:02,180 --> 00:18:13,530
Para esto vamos a enchufar mediante el cable o BSB nuestra placa Arduino al puerto USB de la computadora.

166
00:18:13,870 --> 00:18:23,020
Por lo general no necesitamos instalar drivers especiales pero si no es reconocido por tu ordenador

167
00:18:23,230 --> 00:18:27,430
vamos a dejar los links para que puedas bajar los diferentes drivers

168
00:18:31,210 --> 00:18:32,530
vamos herramientas

169
00:18:35,220 --> 00:18:43,970
en Puerto vamos a ver que nos aparezca Arduino barras genuino uno o algo similar y lo vamos a seleccionar.

170
00:18:44,370 --> 00:18:52,830
Luego vamos otra vez herramientas Plaka y elegimos cuál es la placa que tenemos en este caso genuino.

171
00:18:52,840 --> 00:18:59,850
1 entonces ya estaríamos para compilar y cargar nuestro primer programa.

172
00:18:59,930 --> 00:19:07,120
Para esto tenemos dos opciones este botón que está aquí lo que va a hacer es compilar el programa Esto

173
00:19:07,120 --> 00:19:13,780
quiere decir que lo voy a empaquetar para Lick y dejarlo listo para cargar en la placa pero no lo va

174
00:19:13,780 --> 00:19:14,170
a cargar.

175
00:19:14,170 --> 00:19:16,940
Simplemente nos va a decir si hubo algún error o no.

176
00:19:17,790 --> 00:19:19,330
Vamos a probar de compilar.

177
00:19:19,420 --> 00:19:24,160
Miren dice compilando programa compilado.

178
00:19:24,180 --> 00:19:31,470
Esto quiere decir que no tuvimos ningún error y acá nos da algo de estadísticas de cuánta memoria EPROM

179
00:19:31,560 --> 00:19:40,730
usamos cuánta memoria RAM usamos desde luego con un programa tan chico es muy poco pero miren si yo

180
00:19:40,740 --> 00:19:48,640
me equivoco en algo ya me da error y me dice que no es un nombre o un tipo de variable claro.

181
00:19:51,760 --> 00:19:55,920
Otra opción que tenemos cuando queremos cargarla en la placa es presionar este botón.

182
00:19:55,960 --> 00:20:01,960
Este botón va a hacer las dos cosas primero con pila y después lo cargue en la placa vamos antes les

183
00:20:01,960 --> 00:20:10,000
digo cuando carguen vean que las luces TX y RX van a parpadear porque van a estar ingresando los datos

184
00:20:10,000 --> 00:20:19,230
del programa hacia el microcontrolador a través del puerto serie vamos subiendo y ya subió es bastante

185
00:20:19,230 --> 00:20:19,640
rápido

186
00:20:22,450 --> 00:20:29,440
no sólo subió sino que está funcionando el programa en el interior de la placa está contando y sumando.

187
00:20:29,680 --> 00:20:38,070
Pero como me entero no puedo verlo que sucede créanme que sucede pero no tengo cómo saber y por eso

188
00:20:38,190 --> 00:20:48,440
es que vamos a utilizar una manera para poder ver cómo aumentan esos datos entonces lo que vamos a hacer

189
00:20:48,560 --> 00:20:56,020
es sacar el valor de cuenta por el puerto serial lo vamos a sacar en definitiva por el puerto BSB y

190
00:20:56,030 --> 00:20:59,410
lo vamos a ver en lo que se llama monitor serial.

191
00:20:59,630 --> 00:21:05,750
Para hacer esto lo que vamos a hacer es en el ZetaP o sea esto va a ser código que se va a ejecutar

192
00:21:06,050 --> 00:21:07,310
una sola vez.

193
00:21:07,340 --> 00:21:13,160
Esto es muy útil lo vamos a usar siempre porque en todo momento vamos a necesitar ver qué pasa adentro

194
00:21:13,160 --> 00:21:19,760
del microcontrolador entonces vamos a declarar el puerto serial y se hace de la siguiente manera seria

195
00:21:19,790 --> 00:21:27,400
serial punto Beguin y vamos a poner la velocidad en la que vamos a trabajar este puerto.

196
00:21:27,570 --> 00:21:31,050
Vamos a elegir una baja velocidad aunque a ciencia cierta.

197
00:21:31,050 --> 00:21:36,810
El Arduino Uno es tan noble que puede andar a uno a lo que se considera una alta velocidad que son 115

198
00:21:36,810 --> 00:21:43,360
1200 baudios pero vamos a poner una velocidad muy lenta que a nosotras nos recontra sobra.

199
00:21:43,390 --> 00:21:48,660
Sería bien seria el Beguin 9600 punto y coma.

200
00:21:48,690 --> 00:21:55,970
Este es un buen detalle que no les dije todas las líneas en C++ van a terminar siempre en Punto y Coma

201
00:21:56,010 --> 00:21:57,120
todas las instrucciones

202
00:22:00,040 --> 00:22:09,640
paso seguido vamos a imprimir por pantalla un mensaje para hacer esto vamos a usar serial punto print

203
00:22:10,970 --> 00:22:12,620
Ln Ln.

204
00:22:12,620 --> 00:22:17,900
Lo voy a usar cuando quiero que me deje un salto de línea que me genera un nuevo renglón para imprimir

205
00:22:17,900 --> 00:22:25,740
esto si no tuviera el LNE escribe Vega o va a ir imprimiendo en la pantalla.

206
00:22:26,020 --> 00:22:30,970
Oraciones al lado de la otra hacia diferentes caracteres uno al lado del otro.

207
00:22:31,060 --> 00:22:35,340
En cambio con print LNE lo que haces imprime la oración que yo quiero.

208
00:22:35,350 --> 00:22:41,580
Deja un renglón imprimió otra deja un renglón bueno pero igual se lo vamos a practicar no se preocupen.

209
00:22:41,620 --> 00:22:50,960
Print LN entre comillas por qué entre comillas porque como habíamos visto antes todas o todos mejor

210
00:22:50,960 --> 00:23:04,740
dicho los strings o cadenas de texto u oraciones van entre comillas dobles práctica con Robbiano luego

211
00:23:04,740 --> 00:23:08,550
de los paréntesis vengo com punto y coma.

212
00:23:11,400 --> 00:23:21,430
Bien CTO lavelocidad una buena práctica que podamos Tomares de hacer que el Arduino espere un ratito

213
00:23:21,520 --> 00:23:24,370
antes de empezar a imprimir por serial.

214
00:23:24,370 --> 00:23:32,230
Luego de hacerlo arrancar recuerden con esta línea yo lo que hago es pongo en marcha o arranco la interface

215
00:23:32,230 --> 00:23:38,900
serial de la placa Arduino pero es bueno dejarle un pequeño lapso para darle tiempo a que esto suceda

216
00:23:38,990 --> 00:23:40,500
antes de empezar a usarla.

217
00:23:40,520 --> 00:23:41,710
Entonces para qué.

218
00:23:41,780 --> 00:23:45,260
Para generar este Dili o este tiempo de espera.

219
00:23:45,260 --> 00:23:54,570
Utilizamos una función llamada Dealey y entre paréntesis tengo que pasarle un entero es entero a representar

220
00:23:54,570 --> 00:24:01,950
la cantidad de milisegundos de entendamos que con 1000 milisegundos hago un segundo que quiero que espere

221
00:24:02,010 --> 00:24:04,410
sin hacer nada el largo y nos vamos a darle tiempo.

222
00:24:04,410 --> 00:24:13,540
La verdad es que con 100 milisegundos alcanza y sobra para que arranque el puerto serial voy a imprimir

223
00:24:13,900 --> 00:24:14,710
esta oración

224
00:24:17,610 --> 00:24:22,410
y luego el programa va a entrar en el club recuerdan.

225
00:24:22,460 --> 00:24:26,590
Esto se va a ejecutar una sola vez y luego empieza a repetirse esto.

226
00:24:27,160 --> 00:24:33,990
Entonces lo que quiero hacer ahora es ir viendo el valor que tiene cuenta mientras se va ejecutando

227
00:24:33,990 --> 00:24:35,060
nuestro programa.

228
00:24:35,130 --> 00:24:44,430
Para esto vamos a hacer lo siguiente serial punto print ln y entre paréntesis voy a pasar

229
00:24:48,830 --> 00:24:58,130
el valor en string o sea en caracteres o en cadena de caracteres de la variable cuenta un momento sé

230
00:24:58,150 --> 00:25:07,300
que acá ustedes esperaban que yo pusiera directamente cuenta si si bien puede andar pero nos tenemos

231
00:25:07,300 --> 00:25:12,800
que acostumbrar a que cuenta es un entero pero esta función para imprimir.

232
00:25:12,820 --> 00:25:21,490
Espera que le pasemos caracteres entonces lo correcto es convertir primero el número entero en un carácter

233
00:25:21,570 --> 00:25:27,700
o si son así es un número largo o grande que sea una cadena de caracteres para convertir una entero

234
00:25:28,150 --> 00:25:29,060
a caracteres.

235
00:25:29,080 --> 00:25:38,970
Es muy fácil con la función string y entre paréntesis voy a pasar la variable cuenta por qué tengo dos

236
00:25:38,970 --> 00:25:47,730
paréntesis al final no vamos a aclarar este paréntesis este paréntesis de acá está cerrando éste y acá

237
00:25:48,410 --> 00:25:53,200
está cerrando con este bueno como en realizar un supuesto

238
00:25:56,080 --> 00:25:56,510
listo.

239
00:25:56,530 --> 00:25:58,480
Grave error.

240
00:25:58,870 --> 00:26:03,610
Tengo todo bien y procedemos a cargarlo listo.

241
00:26:03,670 --> 00:26:09,790
Se está cargando y ya lo tenemos corriendo en el árbol y cómo hacemos para ver lo que está saliendo

242
00:26:09,790 --> 00:26:11,210
por el puerto serial.

243
00:26:11,320 --> 00:26:16,420
Vamos a herramientas y vamos a monitor serie

244
00:26:19,920 --> 00:26:25,620
de inmediato se ha abierto y como ven están corriendo números pero a una velocidad increíble.

245
00:26:25,620 --> 00:26:28,950
Yo voy a presionar el botón Reset voy a presionar el botón Reset.

246
00:26:29,030 --> 00:26:29,310
Miren

247
00:26:32,910 --> 00:26:37,720
pasó algo tan rápido que no lo pude ver qué está pasando acá.

248
00:26:37,720 --> 00:26:39,490
Bueno vamos a analizar un poco.

249
00:26:39,660 --> 00:26:48,950
En primer lugar después de imprimir este string a mí me gustaría generar otro delay como para tener

250
00:26:48,950 --> 00:26:54,050
tiempo de verlo porque en cuanto se ejecuta esto empieza el loop y no me deja verlo.

251
00:26:54,050 --> 00:27:02,330
Entonces vamos a generar un diploide dos segundos y lo que está sucediendo ya se darán cuenta es que

252
00:27:02,420 --> 00:27:10,120
este club se ejecuta tan rápido de que prácticamente no me deja ver los números.

253
00:27:10,120 --> 00:27:21,160
Entonces yo puedo generar entre impresión e impresión un Willey vamos a hacer de un segundo perfecto

254
00:27:22,100 --> 00:27:32,490
grabo de nuevo ya puedo ir preparando el monitor serie fijense que arrancó sin problemas y ahora a una

255
00:27:32,490 --> 00:27:36,030
velocidad mucho más acorde y legible.

256
00:27:36,030 --> 00:27:40,950
Voy a borrar con este botón borrar la salida pero en borrar y reseteo.

257
00:27:40,950 --> 00:27:45,750
Presiona el botón de reset mi primera práctica con Arduino.

258
00:27:45,820 --> 00:27:51,390
Dos segundos y empiezo a ver el valor de cuenta cada vez que pasa por el club.

259
00:27:51,450 --> 00:27:52,330
Ven claro es

260
00:27:58,960 --> 00:28:04,710
vamos a mejorar un poquito esto vamos a querer una variable de tipo string que va a ser igual.

261
00:28:05,710 --> 00:28:11,260
Perdón que le voy a llamar saludo y va a ser igual.

262
00:28:11,460 --> 00:28:23,050
Hola alumnos perfecto entonces yo entonces yo acá lo que voy a hacer es reemplazar esta oración por

263
00:28:23,440 --> 00:28:24,090
saludo

264
00:28:28,610 --> 00:28:34,970
ahora voy a presionar este botón para que vean que compila y graba todo al unísono salvo que salvo que

265
00:28:34,970 --> 00:28:36,860
sea un error por supuesto vamos

266
00:28:41,780 --> 00:28:50,170
fíjense que imprimió Hola alumnos cuando se ejecutó esta línea por qué imprimió la alumnos y porque

267
00:28:50,380 --> 00:28:55,090
le estoy pidiendo que imprima una variable no la tengo que convertir a string porque porque ya es una

268
00:28:55,090 --> 00:28:57,940
Extrem y yo había grabado el valor.

269
00:28:58,000 --> 00:28:59,140
Hola alumnos

270
00:29:02,730 --> 00:29:10,330
las variables también pueden ser modificadas a lo largo del programa después de los dos segundos de

271
00:29:10,330 --> 00:29:10,830
espera.

272
00:29:10,870 --> 00:29:22,970
Yo voy a decir que el saludo es igual ahora a varios alumnos punto y coma.

273
00:29:23,720 --> 00:29:31,380
Ahora voy a decir que nuevamente imprima saludo que estoy haciendo copiando y pegando es una excelente

274
00:29:31,670 --> 00:29:38,360
una excelente práctica de todo programador reciclamos código no escribimos todo debemos saber copiar

275
00:29:38,420 --> 00:29:41,210
y pegar porque necesitamos avanzar y hacerlo rápido

276
00:29:44,810 --> 00:29:46,070
bueno vamos a grabar

277
00:29:53,520 --> 00:29:54,220
y ya lo tenemos.

278
00:29:54,220 --> 00:30:04,920
Fijense dijo Hola alumnos porque imprimí el saludo que ya tenía el valor del alumnos y en segundo lugar

279
00:30:05,250 --> 00:30:07,060
dijo adios alumnos por qué.

280
00:30:07,370 --> 00:30:14,010
Porque después de esperar dos segundos yo dije que ahora saludo va a ser iguala a Dios alumnos y luego

281
00:30:14,080 --> 00:30:17,340
imprimir la variable para poder conocer su nuevo valor.

282
00:30:17,610 --> 00:30:26,900
Desde luego después caemos en el blog y se empieza a repetir la impresión de la variable cuenta y ya

283
00:30:26,900 --> 00:30:37,160
como final para esta edición vamos a hacer lo siguiente y es contarles que yo puedo mejorar esta parte

284
00:30:37,160 --> 00:30:48,380
poniendo una string por ejemplo diciendo el valor de cuenta es ponerle una rayita y un signo de mayor

285
00:30:49,040 --> 00:30:51,620
para que quede un poco más lindo.

286
00:30:51,660 --> 00:30:58,370
Y esto se llama concatenar strings como a cuenta yo lo transforma en string con esta función lo que

287
00:30:58,370 --> 00:31:06,250
yo tengo acá es una string o cadena de texto una oración lo que tengo de este lado también es una cadena

288
00:31:06,250 --> 00:31:13,870
de texto con el signo más yo lo que estoy haciendo es unir estas dos cadenas de texto y es totalmente

289
00:31:13,900 --> 00:31:17,470
válido y lícito en esta plataforma.

290
00:31:17,470 --> 00:31:19,440
Vamos a agravarlo por última vez

291
00:31:24,990 --> 00:31:29,140
alumnos cambio del valor a alumnos y miren que ahora sale bastante mejor.

292
00:31:29,140 --> 00:31:29,390
No

293
00:31:34,150 --> 00:31:41,560
vamos a hacerle un espacio para completarlo aún más grabamos

294
00:31:44,370 --> 00:31:48,450
y vemos que ya sale de manera correcta.

295
00:31:48,460 --> 00:31:54,750
Bueno muchísimas gracias por este intenso capítulo que hemos tenido vamos a seguir avanzando no se preocupen.

296
00:31:54,870 --> 00:31:56,040
Y bueno nos vemos la próxima.