Como crear un Robot sumo autónomo Arduino UNO paso a paso "Programación control de motores"

00:21:40
https://www.youtube.com/watch?v=SqOALjtDbjw

Sintesi

TLDREn este video se instruye sobre cómo programar un robot Zoom autónomo para que ejecute movimientos básicos: avanzar, retroceder, girar a la izquierda y a la derecha. Se comienza analizando la conexión y el comportamiento de los motores, declarando y configurando las variables correspondientes en Arduino. Los comandos específicos se desarrollan para cada acción del robot, explicando la lógica detrás del control de los pines de los motores. Al final, se verifica que la programación funcione correctamente y se anticipa la conexión de un sensor ultrasónico en futuros videos.

Punti di forza

  • 🤖 Se programan cuatro movimientos básicos para el robot.
  • 🔌 Los motores deben conectarse correctamente al Arduino.
  • 🛠️ Se utilizan el módulo L298N para controlar los motores.
  • 📝 La programación se realiza mediante variables y comandos digitales.
  • ⏳ Se recomienda usar delays entre movimientos.
  • 💻 Se debe compilar el código para verificar errores.
  • ⬅️ La programación permite girar el robot hacia la izquierda y la derecha.
  • 📦 Se anticipa la conexión de sensores en videos futuros.
  • 🔧 Revisar la configuración del puerto en caso de problemas de conexión.
  • 🗣️ Se anima a los espectadores a hacer preguntas y comentarios.

Linea temporale

  • 00:00:00 - 00:05:00

    En este video se presenta el proceso para programar un robot autónomo para que se mueva en distintas direcciones: adelante, atrás, izquierda y derecha. Se inicia analizando el comportamiento del robot y las variables necesarias para controlar los motores. Cada motor tiene dos pines que se activan con positivo y negativo para cambiar la dirección de giro. Se definen cuatro funciones básicas de movimiento y se introducen las variables necesarias para controlar los motores a través de un Arduino.

  • 00:05:00 - 00:10:00

    Se procede a declarar las variables en el bloque de configuración del Arduino. Se explica cómo cada pín en el Arduino se asigna a un motor específico utilizando el módulo L298N. Además, se aclara que al asignar los pines como salida, se permite enviar voltaje para controlar los motores. Se concluye la configuración con la indicación de conectar y controlar correctamente cada motor a través de los pines definidos en el Arduino.

  • 00:10:00 - 00:15:00

    Se inician las instrucciones para programar el movimiento del robot avanzando hacia adelante, retrocediendo, girando a la izquierda y a la derecha. Se muestra cómo activar cada variable de motor correspondiente, explicando cómo se debe enviar voltajes altos y bajos para mover el robot en las diferentes direcciones, recordando agregar retrasos para que las acciones se realicen correctamente.

  • 00:15:00 - 00:21:40

    Finalmente, se revisa el código para asegurar que el robot se mueva en todas las direcciones deseadas, y se menciona que en futuros videos se añadirán sensores ultrasónicos para mejorar las capacidades del robot, así como ajustes en la programación para asegurar un mejor funcionamiento en todo tipo de entornos. Se concluye con la carga del software en el Arduino y la verificación del funcionamiento del robot.

Mostra di più

Mappa mentale

Video Domande e Risposte

  • ¿Cómo se conecta el robot a Arduino?

    Se conectan los pines de control de los motores al Arduino utilizando el módulo L298N.

  • ¿Qué funciones puede realizar el robot?

    Avanzar hacia adelante, retroceder, girar a la izquierda y girar a la derecha.

  • ¿Qué lenguaje de programación se utiliza?

    Se utiliza el lenguaje de programación de Arduino.

  • ¿Qué se necesita para programar el robot?

    Un Arduino, el módulo L298N, y conocimientos básicos de cómo configurar pines.

  • ¿Cómo se aseguran de que la programación es correcta?

    Compilando el código regularmente para verificar que no haya errores.

  • ¿Qué harán en el siguiente video?

    Realizarán la conexión del sensor ultrasónico al robot.

  • ¿Qué sucede si el Arduino no se detecta?

    Se puede probar cambiar el cable o seleccionar el puerto correcto en la computadora.

  • ¿Es necesario un delay en la programación?

    Sí, se utiliza un delay para permitir que el robot ejecute cada movimiento de forma fluida.

Visualizza altre sintesi video

Ottenete l'accesso immediato ai riassunti gratuiti dei video di YouTube grazie all'intelligenza artificiale!
Sottotitoli
es
Scorrimento automatico:
  • 00:00:00
    Bienvenidos a todos a este cuarto video
  • 00:00:02
    construye tu robot zoom autónomo paso a
  • 00:00:04
    paso en el video del día de hoy veremos
  • 00:00:07
    Cómo realizar la programación para que
  • 00:00:09
    nuestro robot avance hacia delante hacia
  • 00:00:11
    atrás hacia la izquierda y hacia la
  • 00:00:14
    derecha comenzaremos analizando el
  • 00:00:17
    comportamiento que deberá tener nuestro
  • 00:00:18
    robot para saber qué variables vamos a
  • 00:00:21
    utilizar en esta primera parte de
  • 00:00:23
    nuestro
  • 00:00:24
    programa hasta el momento nuestro robot
  • 00:00:27
    tendrá que hacer cuatro funciones la
  • 00:00:29
    cual es avanzar hacia delante avanzar
  • 00:00:31
    hacia atrás avanzar hacia la izquierda y
  • 00:00:35
    avanzar hacia la derecha Por lo cual
  • 00:00:38
    sucede lo
  • 00:00:39
    siguiente cada uno de nuestros de
  • 00:00:41
    nuestros motores tiene dos Pines que al
  • 00:00:45
    alimentarlos con positivo y negativo y
  • 00:00:48
    cambiarlo los motores cambian su sentido
  • 00:00:50
    de giro Así que para que robot avance
  • 00:00:53
    hacia delante necesitamos activar este
  • 00:00:58
    compositivo y este con
  • 00:01:01
    positivo y los otros dos con
  • 00:01:06
    negativo para que robot retroceda
  • 00:01:09
    hacemos lo mismo pero cambiando lo que
  • 00:01:13
    son los positivos hacia los la parte
  • 00:01:15
    trasera de la siguiente forma positivo
  • 00:01:19
    en las
  • 00:01:24
    traseras y negativo en los delanteros
  • 00:01:28
    para que robot avance hacia la izquierda
  • 00:01:32
    ahora Tendremos que
  • 00:01:35
    alimentar este motor que vaya hacia
  • 00:01:38
    delante de esta forma y el motor de la
  • 00:01:41
    izquierda tendrá que ir hacia
  • 00:01:46
    atrás y para que el robot avance hacia
  • 00:01:49
    la
  • 00:01:50
    derecha irá de forma invertida por lo
  • 00:01:54
    que este se alimenta de forma positiva
  • 00:02:00
    y el otro de positivo y negativo por lo
  • 00:02:05
    que podemos observar que para que
  • 00:02:07
    nuestro robot ejecute los movimientos
  • 00:02:11
    tenemos una dos tres cuatro variables Y
  • 00:02:16
    a partir de aquí comenzamos con la
  • 00:02:18
    programación lo primero que haremos será
  • 00:02:21
    declarar las variables que nos
  • 00:02:23
    permitirán controlar los
  • 00:02:25
    motores comenzaremos antes del vo Setup
  • 00:02:28
    se realiza lo que es esta declaración
  • 00:02:31
    agregamos dos diagonales y ponemos un
  • 00:02:34
    comentario
  • 00:02:36
    variables
  • 00:02:37
    motor este comentario nos permite que si
  • 00:02:40
    tenemos algún error en la programación
  • 00:02:43
    sepamos Dónde se puede corregir después
  • 00:02:46
    comenzaremos declarando como variable
  • 00:02:49
    entera y
  • 00:02:51
    n1 igual al pin 13 de nuestro ardino
  • 00:02:56
    esto quiere decir que a la variable
  • 00:03:00
    llamada in1 le podemos mandar con la
  • 00:03:03
    palabra clave in ya sea voltaje o tierra
  • 00:03:07
    y Esto va a suceder en el pin 1 de
  • 00:03:10
    arduino realizamos esto también en la
  • 00:03:14
    siguiente que será in y n2 y este va al
  • 00:03:18
    pin 12 de arduino después
  • 00:03:22
    in
  • 00:03:25
    in3 igual al pin 11 de nuestro arduino y
  • 00:03:31
    finalmente in in Perdón
  • 00:03:36
    in4 igual al pin 10 de nuestro ardino y
  • 00:03:41
    con con esto vamos a poder por medio de
  • 00:03:44
    programación controlar cada uno de los
  • 00:03:46
    Pines de motores para cambiar el giro
  • 00:03:49
    sin necesidad de desconectarlo y con
  • 00:03:52
    ayuda del módulo
  • 00:03:54
    l298n lo que haremos ahora será
  • 00:03:57
    configurar las variables que acabamos de
  • 00:03:58
    declarar esto lo haremos en la parte del
  • 00:04:01
    Bo Setup por lo que agregaremos otro
  • 00:04:04
    comentario que nos dirá bueno que se
  • 00:04:08
    nombrará
  • 00:04:11
    configuración
  • 00:04:13
    variables de los
  • 00:04:16
    motores y lo que haremos será agregar la
  • 00:04:19
    palabra clave
  • 00:04:21
    pin
  • 00:04:23
    Mode la cual nos permitirá
  • 00:04:27
    configurar los Pines con como entradas o
  • 00:04:30
    salidas en este caso como nosotros
  • 00:04:33
    controlaremos motores se tratará de una
  • 00:04:36
    salida ya que debemos de mandar voltaje
  • 00:04:39
    para que funcione Así que escribimos el
  • 00:04:43
    nombre de la variable que vamos a
  • 00:04:45
    configurar que sería in1 la primera
  • 00:04:49
    ponemos coma y ponemos la palabra en
  • 00:04:52
    inglés salida
  • 00:04:56
    output sin olvidar poner el punto y coma
  • 00:05:03
    y realizamos esta configuración con las
  • 00:05:06
    otras tres variables que sería pin
  • 00:05:09
    Mode
  • 00:05:11
    abrimos paréntesis variable
  • 00:05:14
    in2 Coma configurada Como salida
  • 00:05:19
    output y agregamos punto y coma luego
  • 00:05:24
    pin
  • 00:05:25
    Mode abrimos paréntesis y n
  • 00:05:30
    3 coma configurada como salida
  • 00:05:34
    output sin olvidar poner punto y coma y
  • 00:05:40
    finalmente pin
  • 00:05:44
    Mode abrimos paréntesis
  • 00:05:49
    in4
  • 00:05:51
    coma
  • 00:05:53
    output punto y coma con esto cada una de
  • 00:05:57
    las variables que tenemos Tenemos aquí
  • 00:06:00
    va a funcionar como una salida para
  • 00:06:03
    alimentar los
  • 00:06:04
    motores para dejar un poquito más clara
  • 00:06:08
    la programación analizaremos el
  • 00:06:10
    comportamiento del módulo
  • 00:06:13
    l298n
  • 00:06:15
    nosotros vamos a por medio del pin 13
  • 00:06:20
    alimentar in1 que es este punto bueno
  • 00:06:23
    esta entrada y la señal se va a mandar
  • 00:06:27
    hacia esta salida que es el output 1 del
  • 00:06:32
    l298n y que va a controlar un pin del
  • 00:06:35
    motor y n2 que es el pin 12 mandará una
  • 00:06:40
    señal a in2 que controla esta salida o2
  • 00:06:46
    del módulo
  • 00:06:53
    l298n el
  • 00:06:56
    pin 11 de arduino manda una señal a in3
  • 00:07:01
    que va a controlar
  • 00:07:03
    out 3 que es la salida este 3 del módulo
  • 00:07:09
    l298n y finalmente lo que es in4 la
  • 00:07:14
    variable
  • 00:07:14
    in4 que está conectada al pin 10 de
  • 00:07:19
    nuestro ardino controlará out
  • 00:07:23
    4 que mandará el voltaje o tierra a
  • 00:07:29
    nuestro nuestro motor para poder
  • 00:07:31
    controlar el
  • 00:07:33
    giro ahora para finalizar en la parte de
  • 00:07:36
    voot vamos a escribir los comandos
  • 00:07:39
    necesarios para que nuestro robot avance
  • 00:07:42
    hacia delante atrás izquierda y derecha
  • 00:07:44
    esto en base a las variables ya
  • 00:07:46
    declaradas y ya configuradas iniciaremos
  • 00:07:50
    agregando un comentario con las dos
  • 00:07:53
    diagonales indicando que
  • 00:07:55
    robot avanza hacia adelante
  • 00:08:01
    recordando que para que robot avance
  • 00:08:04
    hacia delante vamos a tener que activar
  • 00:08:07
    este pin del motor y este se va a
  • 00:08:09
    activar con el pin 13 que es in1 que va
  • 00:08:13
    a controlar lo que es out 1 que está
  • 00:08:18
    conectado a nuestro módulo
  • 00:08:22
    l298n esta configuración ya está
  • 00:08:25
    realizada desde el video anterior donde
  • 00:08:27
    realizamos la conexión de este m
  • 00:08:30
    ahora el otro pin lo activaremos el pin
  • 00:08:35
    12 de arduino que representa la variable
  • 00:08:38
    in2 conectada a out2 que donde
  • 00:08:42
    mandaremos un valor bajo para que este
  • 00:08:45
    motor avance hacia adelante en el otro
  • 00:08:48
    motor vamos a activar lo que es el pin
  • 00:08:51
    11 que está conectado hacia in3 y que
  • 00:08:55
    está controlando lo que es out3 Y en
  • 00:08:58
    este caso conectado a a este Pin y
  • 00:09:01
    finalmente solamente activaremos lo que
  • 00:09:04
    es el pin 10 que está conectado a in4
  • 00:09:08
    que controla el negativo y le mandaremos
  • 00:09:11
    un valor bajo para realizar estas
  • 00:09:14
    acciones lo siguiente será escribir la
  • 00:09:18
    palabra clave
  • 00:09:28
    digital La que nos indicará si el valor
  • 00:09:32
    que vamos a mandar es alto o bajo ya que
  • 00:09:34
    tenemos una variable entera escribimos
  • 00:09:36
    aquí la variable que vamos a controlar
  • 00:09:38
    que sería
  • 00:09:39
    in1 coma y recordando que le mandaremos
  • 00:09:43
    un valor
  • 00:09:44
    alto con la palabra
  • 00:09:48
    high ponemos punto y coma después
  • 00:09:52
    volvemos a escribir instrucción
  • 00:09:57
    digital abrimos paréntesis y aquí
  • 00:10:01
    escribiremos la otra variable que es
  • 00:10:03
    in2 que está conectada al pin 13 y al
  • 00:10:07
    pin 12 perdón y mandaremos lo que es un
  • 00:10:10
    voltaje bajo con la palabra clave
  • 00:10:12
    low ponemos punto y
  • 00:10:15
    coma después escribimos
  • 00:10:19
    digital
  • 00:10:22
    right abrimos paréntesis escribimos la
  • 00:10:25
    variable que sería
  • 00:10:27
    in3 que está conectada al pin 11 el cual
  • 00:10:32
    va a activar un valor
  • 00:10:35
    alto y
  • 00:10:37
    cerramos bueno y ponemos lo que es el
  • 00:10:39
    punto y coma y finalmente debemos mandar
  • 00:10:42
    la tierra a la otra variable que sería
  • 00:10:47
    digital
  • 00:10:49
    right abrimos
  • 00:10:52
    paréntesis escribimos la variable que
  • 00:10:54
    sería
  • 00:10:55
    in4 que es encargada de controlar el pin
  • 00:10:59
    10 y con el cual mandaremos un valor
  • 00:11:02
    bajo ponemos punto y coma y adicional
  • 00:11:05
    esto vamos a agregar un
  • 00:11:07
    delay para que esta bueno para que la
  • 00:11:10
    siguiente acción se ejecute después de
  • 00:11:13
    cierto tiempo en este caso solamente
  • 00:11:15
    agregaremos un segundo que está
  • 00:11:18
    representado en milis segundos por eso
  • 00:11:19
    se representa con 1 ponemos punto y coma
  • 00:11:22
    y compilamos nuestro programa para
  • 00:11:24
    verificar que no haya ningún error
  • 00:11:29
    ahí podemos ver que la compilación fue
  • 00:11:32
    exitosa la siguiente acción a realizar
  • 00:11:35
    va a ser que nuestro robot retroceda que
  • 00:11:37
    vaya hacia atrás Así que agregamos otro
  • 00:11:40
    comentario con los dos diagonales
  • 00:11:43
    escribimos
  • 00:11:44
    robot
  • 00:11:46
    avanza hacia
  • 00:11:50
    atrás y observamos que para que nuestro
  • 00:11:54
    robot retroceda se tiene que hacer lo
  • 00:11:57
    contrario de aquí es de decir este pin
  • 00:12:00
    tiene que estar en negativo y este pin
  • 00:12:04
    tiene que estar en positivo este pin
  • 00:12:07
    tiene que estar en negativo y este pin
  • 00:12:10
    tiene que estar en positivo simplemente
  • 00:12:12
    lo que haremos en nuestra programación
  • 00:12:14
    será invertir los valores es decir in1
  • 00:12:18
    que está en High lo vamos a mandar a low
  • 00:12:20
    y2 que está en low lo mandamos a High
  • 00:12:24
    in3 que está en High lo dejamos en low y
  • 00:12:27
    en in4 que está
  • 00:12:29
    le mandamos un valor alto con High Así
  • 00:12:32
    que escribimos escribimos
  • 00:12:35
    digital
  • 00:12:37
    right abrimos paréntesis variable
  • 00:12:41
    in1 y escribimos valor
  • 00:12:44
    bajo escribimos punto y
  • 00:12:49
    coma después escribimos digital
  • 00:12:55
    W paréntesis y n2
  • 00:13:00
    le mandamos un valor alto ya que
  • 00:13:03
    anteriormente era
  • 00:13:04
    bajo ponemos punto y coma escribimos
  • 00:13:08
    digital
  • 00:13:12
    W abrimos paréntesis variable
  • 00:13:15
    in3 anteriormente era valor alto Así que
  • 00:13:18
    mandamos un valor este bajo que sería
  • 00:13:22
    load ponemos punto y
  • 00:13:24
    coma después escribimos digital
  • 00:13:31
    con un valor bueno con la variable
  • 00:13:36
    in4 coma y escribimos acá abajo que sea
  • 00:13:40
    valor
  • 00:13:42
    alto ponemos punto y coma agregamos otro
  • 00:13:46
    tiempo un delay de un segundo
  • 00:13:51
    también y esta acción nos va a permitir
  • 00:13:54
    que nuestro robot retroceda es
  • 00:13:56
    conveniente que cuando realices
  • 00:13:59
    programación compiles constantemente
  • 00:14:01
    para verificar que no haya ningún error
  • 00:14:03
    yo por ejemplo en esta línea Me faltó
  • 00:14:06
    agregar lo que es la letra
  • 00:14:09
    l para que funcione correctamente el
  • 00:14:11
    comando por si llegases a tener un error
  • 00:14:15
    podría ser ese también lo que te pueda
  • 00:14:17
    pasar así que aquí voy a verificar y
  • 00:14:20
    está funcionando correctamente ya
  • 00:14:22
    compiló
  • 00:14:25
    correctamente ahora escribiremos El
  • 00:14:27
    Comando que nos permitirá
  • 00:14:29
    que nuestro robot avance hacia la
  • 00:14:31
    izquierda Así que agregamos el
  • 00:14:36
    comentario
  • 00:14:39
    robot avanza a la
  • 00:14:43
    izquierda y lo que tiene que suceder
  • 00:14:46
    para que robot realice esta acción sería
  • 00:14:49
    que este robot Bueno este motor más bien
  • 00:14:52
    avance hacia delante y este motor de acá
  • 00:14:56
    de atrás este bueno de la izquierda
  • 00:14:59
    retroceda para que el robot pueda girar
  • 00:15:01
    hacia la izquierda es una forma de
  • 00:15:03
    movimiento de diferencial Así que si
  • 00:15:06
    nosotros observamos este motor para que
  • 00:15:09
    vaya adante este de arriba Tendría que
  • 00:15:12
    ir en positivo y este de abajo en
  • 00:15:15
    negativo y este pin tendría que quedar
  • 00:15:18
    en
  • 00:15:19
    negativo y este tendría que quedar en
  • 00:15:22
    positivo
  • 00:15:24
    ahora si nos vamos a lo que es esta
  • 00:15:26
    parte de nuestra programación
  • 00:15:30
    esto permite que todos los motores vayan
  • 00:15:33
    hacia hacia delante y queremos que el
  • 00:15:36
    motor izquierdo vaya hacia hacia atrás
  • 00:15:39
    el cual está controlado por in1 y y n2
  • 00:15:45
    por lo que estos los vamos a tener que
  • 00:15:48
    dejar invertidos y n1 en bajo y y n2 en
  • 00:15:54
    alto para que el motor vaya hacia atrás
  • 00:15:56
    Así que nos quedaría de la siguiente
  • 00:15:57
    forma
  • 00:16:00
    digital
  • 00:16:02
    Wi abrimos paréntesis y
  • 00:16:06
    n1 coma y queremos que el motor vaya
  • 00:16:09
    hacia atrás así que sería valor bajo
  • 00:16:13
    para que el p delantero le mande un
  • 00:16:15
    valor negativo después sería
  • 00:16:20
    digital
  • 00:16:24
    right abrimos paréntesis y
  • 00:16:27
    n2 coma a este le mandamos un
  • 00:16:31
    valor
  • 00:16:34
    alto ponemos lo que es punto y coma
  • 00:16:38
    después escribimos digital
  • 00:16:44
    Wi ponemos
  • 00:16:46
    in 3 escribimos un valor en este caso
  • 00:16:51
    alto porque ese motor sí queremos que
  • 00:16:53
    vaya hacia
  • 00:16:54
    adelante sería High
  • 00:17:00
    punto y coma digital
  • 00:17:09
    Wi y
  • 00:17:13
    n4 coma y este valor
  • 00:17:19
    va Hay que agregar también un
  • 00:17:24
    delay abrimos lo dejamos de un segundo
  • 00:17:27
    también punto y coma y también la parte
  • 00:17:30
    de digital Wi la W es mayúscula no
  • 00:17:33
    olvidar esa parte porque nos podría
  • 00:17:35
    marcar un error compilamos para
  • 00:17:37
    verificar que todo esté correcto y
  • 00:17:40
    observamos
  • 00:17:42
    finalmente vamos a hacer que nuestro
  • 00:17:45
    robot vaya hacia la
  • 00:17:46
    izquierda abrimos lo que son este
  • 00:17:50
    comentario robot
  • 00:17:52
    avanza hacia la
  • 00:17:56
    derecha y vamos a empezar a observar con
  • 00:18:00
    este Comando con esta configuración
  • 00:18:03
    nuestro robot avanzaría hacia la
  • 00:18:05
    izquierda quiere decir que tenemos que
  • 00:18:07
    hacer lo contrario Así que lo que es in1
  • 00:18:10
    va a estar en alto in2 va a estar en
  • 00:18:13
    bajo y n3 va a estar en bajo y y n4 va a
  • 00:18:19
    estar en en alto para que el robot
  • 00:18:23
    avance hacia la derecha ya que el motor
  • 00:18:25
    izquierdo avanza hacia delante el
  • 00:18:27
    derecho hacia atrás y le va permitir
  • 00:18:29
    girar lo realizamos de la siguiente
  • 00:18:30
    forma sería
  • 00:18:34
    digital
  • 00:18:36
    right abrimos paréntesis sería
  • 00:18:41
    in1 el cual activamos con un valor
  • 00:18:49
    alto ponemos punto y coma escribimos
  • 00:18:54
    digital
  • 00:18:57
    right abrimos paréntesis
  • 00:19:00
    in2 Coma Como el in1 ya está en alto
  • 00:19:04
    este será en bajo ponemos punto y coma
  • 00:19:07
    escribimos
  • 00:19:09
    digital
  • 00:19:13
    right y
  • 00:19:16
    n3 coma escribimos lo que es un valor
  • 00:19:21
    bajo Bueno este un valor bajo para que
  • 00:19:24
    el motor vaya hacia atrás punto y coma
  • 00:19:28
    después
  • 00:19:30
    digital
  • 00:19:32
    right paréntesis
  • 00:19:34
    y4 y este sería en valor
  • 00:19:39
    alto para que este motor avance hacia
  • 00:19:42
    atrás con esta configuración ahora
  • 00:19:46
    nuestro robot avanzará hacia delante
  • 00:19:48
    hacia atrás izquierda y derecha esto
  • 00:19:50
    solamente es para probar el
  • 00:19:51
    funcionamiento de los motores ya que nos
  • 00:19:54
    falta agregar el sensor ultrasónico para
  • 00:19:57
    detectar a componente y agregar el
  • 00:20:00
    módulo 3r 5000 para detectar el borde de
  • 00:20:03
    ring Y que nuestro robot no salga en el
  • 00:20:06
    siguiente video vamos a realizar la
  • 00:20:08
    conexión electrónica del del sensor
  • 00:20:12
    ultrasónico y posteriormente en otro
  • 00:20:14
    video realizaremos la configuración en
  • 00:20:17
    la programación ahora veremos el
  • 00:20:20
    resultado final Como se mostró en el
  • 00:20:23
    inicio del video Solamente necesitamos o
  • 00:20:27
    bastaría cargar lo que es el software a
  • 00:20:30
    nuestro
  • 00:20:31
    robot aquí yo ya he conectado el arduino
  • 00:20:35
    a la computadora y para saber que está
  • 00:20:38
    conectado vemos Que aquí se habilita lo
  • 00:20:40
    que es la parte de arduino Pero uno pero
  • 00:20:42
    con letras negritas si te sale como un
  • 00:20:45
    poquito más oscuro que no se letras
  • 00:20:48
    negritas quiere decir que tu arduino no
  • 00:20:50
    lo está detectando aún lo que podrías
  • 00:20:53
    hacer simplemente sería mover y elegir
  • 00:20:56
    el puerto que se habilita en este color
  • 00:20:58
    ahora si aún así no lo detecta pues
  • 00:21:00
    podrías mover un poquito lo que es el
  • 00:21:02
    cable hacia tu placa y podría detectarlo
  • 00:21:06
    así así que por último cargamos
  • 00:21:09
    el la programación a nuestro arduino
  • 00:21:13
    vemos que se compiló y que se subió
  • 00:21:15
    correctamente ahora veremos el resultado
  • 00:21:18
    final de esta programación si seguiste
  • 00:21:21
    todos los pasos tal y como te lo
  • 00:21:22
    mencioné Este es el resultado final que
  • 00:21:24
    debes de Obtener cualquier duda o
  • 00:21:27
    comentario no dudes en decírmelo Y
  • 00:21:29
    espero que te agrade este video
Tag
  • robot
  • Arduino
  • programación
  • motores
  • movimientos
  • sensor ultrasónico
  • L298N
  • control
  • electrónica
  • tutorial