Info

  • Intermedio.
  • Edades: 11+.

Temas STEAM

  • Tecnología
  • Ingeniería
  • Matemáticas.

Logros y habilidades

  • Interactúa con las tarjetas Innobot y Arduino UNO.
  • Programa las tarjetas Innobot y Arduino UNO con BLOCKS y CODE.
  • Construye circuitos sencillos en el protoboard y los conecta a las tarjetas Innobot y Arduino UNO.
  • Afianza la lógica de programación por bloques.
  • Aplica la programación al trabajo con circuitos electrónicos.

Recomendaciones

Sabiendo programar entradas y salidas, digitales y analógicas, puedes explorar y hacer muchos programas. ¡Tu imaginación es el limite!

Introducción

En esta guía presentaremos la tarjeta Innobot y la tarjeta Arduino UNO; y las programaremos con BLOCKS y CODE para usarlas con algunos circuitos sencillos.

Materiales requeridos

  • Tarjeta Innobot.
  • Tarjeta Arduino UNO.
  • Protoboard.
  • Cables jumper.
  • Leds.
  • Led RGB
  • Pulsadores
  • Resistencias de 330Ω y 1KΩ.
  • Potenciómetros 1KΩ.

Desarrollo de la actividad

Verificar conexión.

Primero verificaremos que al conectar la tarjeta Innobot o Arduino UNO al computador, el programa BLOCKS la reconozca. Para hacerlo, conectamos la tarjeta al computador por medio del cable USB y verificar que en el desplegable “Tarjeta que usara” diga “Innobot” o “UNO” respectivamente y en “Puerto de conexión” diga “COM#”.

Cuando el programa este subiendo a la tarjeta cualquiera de las tarjetas, los leds Tx y Rx se encenderán; y si el programa subió satisfactoriamente, sale en la parte inferior de la pantalla de BLOCKS o CODE un letrero que dice “Estado: Finalizado”.

Programa 1: ¡Hola mundo!

Ahora realizaremos un programa que encienda y apague cada segundo el led incorporado en el pin 13 de la tarjeta Innobot y Arduino UNO.

Paso 1

Abrimos BLOCKS y escribimos el siguiente programa. En el campo Configuraciones buscamos “Modo de pin…”, este bloque nos sirve para definir si el pin se usara como entrada o salida. En Salida buscamos el bloque “Escritura Digital”, este bloque sirve para poner en estado ALTO o BAJO el pin seleccionado (encender o apagar). Por último, en Configuraciones, buscamos el bloque “Esperar”, en este se debe poner la cantidad de tiempo en milisegundos que se quiere que espere el programa antes de continuar con el siguiente bloque.

Paso 1

En CODE, construye el siguiente código.

/**********************************/
/* Empresa:       Pygmalion       */ 
/* Fecha:         26-06-2018      */
/* Nombre:        Hola mundo!     */
/* Autor:         Felipe Arias    */
/**********************************/

void setup ()
{
  pinMode(13, OUTPUT);      //declaramos el pin 13 como salida
}

void loop ()
{
  digitalWrite(13, HIGH);   //encendemos el led del pin 13
  delay(1000);              //esperamos 1 segundo
  digitalWrite(13, LOW);    //apagamos el led del pin 13
  delay(1000);              //esperamos un segundo
}

Paso 2

Después de verificar que el programa reconoce la tarjeta que tenemos conectada, damos clic en el botón “Subir” para cargar el programa en la tarjeta Innobot o Arduino; y verificamos que el led 13 incorporado prende por un según y se apaga por un segundo indefinidamente.

Programa 2: Pulsador + Led

Ahora encendemos un led cada que presionemos un pulsador.

Paso 1

Armamos el siguiente circuito.

Si es con Innobot:

Si es con Arduino UNO:

Paso 2

Hacemos el siguiente programa. Si oprimimos el pulsador, se enciende el led; si no, se apaga.

Paso  2

En CODE, construye el siguiente código.

/**********************************/
/* Empresa:       Pygmalion       */ 
/* Fecha:         26-06-2018      */
/* Nombre:        Pulsador + led  */
/* Autor:         Felipe Arias    */
/**********************************/

void setup ()
{
  pinMode(2, OUTPUT);           //declaramos el pin 2 como salida
  pinMode(3, INPUT);            //declaramos el pin 3 como entrada
}

void loop ()
{
  if (digitalRead(3) == HIGH)   //si presionamos el pulsador...
  {
    digitalWrite(2, HIGH);      //encendemos el led
  }
  else                          //de lo contrario...
  {
    digitalWrite(2, LOW);       //apagamos el led
  }
}

Programa 3: Semáforos de una intersección

Ahora vamos a montar el circuito de dos semáforos en la protoboard y vamos a programar el Arduino para que encienda en la secuencia correcta estos dos semáforos.

Paso 1

Montamos el siguiente circuito en la protoboard y lo conectamos a la tarjeta que vayamos a usar:

Si es con Innobot:

Si es con Arduino UNO:

Paso 2

Diseñamos la secuencia de encendido de los dos semáforos:

Nota: el pin 8 de la tarjeta Innobot no debemos usarlo ya que en este esta conectado el speaker. Por eso, usamos el pin 7 en la Innobot en vez del pin 8.

Paso 3

Si vamos a usar la tarjeta Innobot, realizamos el siguiente programa en BLOCKS. Primero hacemos la parte de Configuración:

Luego hacemos la parte de Ciclo Infinito:

Si vamos a programar en la tarjeta Arduino UNO, el programa es el siguiente:

Paso 3

En CODE, construye el siguiente código.

Si es con Innobot:

/**********************************/
/* Empresa:       Pygmalion       */ 
/* Fecha:         26-06-2018      */
/* Nombre:        Semáforos de una intersección  */
/* Autor:         Felipe Arias    */
/**********************************/

void setup ()               //definimos los pines de salida
{
  pinMode(7, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
}

void loop ()                //realizamos la secuencia de ambos semaforos al tiempo
{
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);
  delay(4000);
  digitalWrite(11, LOW);
  digitalWrite(12, HIGH);
  delay(1000);
  digitalWrite(12, LOW);
  digitalWrite(10, LOW);
  digitalWrite(13, HIGH);
  digitalWrite(7, HIGH);
  delay(4000);
  digitalWrite(7, LOW);
  digitalWrite(9, HIGH);
  delay(1000);
  digitalWrite(9, LOW);
  digitalWrite(13, LOW);
}

Si es con Arduino UNO:

/**********************************/
/* Empresa:       Pygmalion       */ 
/* Fecha:         26-06-2018      */
/* Nombre:        Semáforos de una intersección  */
/* Autor:         Felipe Arias    */
/**********************************/

void setup ()               //definimos los pines de salida
{
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
}

void loop ()                //realizamos la secuencia de ambos semaforos al tiempo
{
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);
  delay(4000);
  digitalWrite(11, LOW);
  digitalWrite(12, HIGH);
  delay(1000);
  digitalWrite(12, LOW);
  digitalWrite(10, LOW);
  digitalWrite(13, HIGH);
  digitalWrite(8, HIGH);
  delay(4000);
  digitalWrite(8, LOW);
  digitalWrite(9, HIGH);
  delay(1000);
  digitalWrite(9, LOW);
  digitalWrite(13, LOW);
}

Programa 4: Entradas y salidas analógicas

Ahora realizaremos un programa que encienda un led RGB. La intensidad de cada color la graduaremos con 3 potenciómetros y así lograremos crear diferentes.

Paso 1

Montamos el siguiente circuito en la protoboard:

Si es con Innobot:

Si es con Arduino UNO:

Paso 2

Programamos los pines ~3, ~5 y ~6 como salidas en Configuraciones. Elegimos estos pines ya que estos tienen el símbolo ~, este símbolo significa que este pin se puede usar como salida analógica.

Luego programamos el Ciclo Infinito de cada una de las tres salidas RGB. Los bloques deben ser pegados en el orden mostrado a continuación:

  1. Primero ponemos el bloque “Escritura Analógica”. Este bloque está en Salida.
  2. Dentro de este, ponemos el bloque para dividir “÷”. Este se encuentra en Operadores.
  3. En el dividendo ponemos el bloque “Lectura Analógica”. Este se encuentra en Entrada.
  4. En el divisor ponemos el numero 4. Este bloque se encuentra en Operadores.

Es necesario dividir la entrada por 4, ya que la entrada analógica es de 10 bits, es decir, nos da valores entre 0 y 1023; y la salida es de 8 bits, es decir, que solo puede variar entre 0 y 255.

Paso 2

En CODE, construye el siguiente código.

/**********************************/
/* Empresa:       Pygmalion       */ 
/* Fecha:         26-06-2018      */
/* Nombre:        Entradas y salidas analógicas*/
/* Autor:         Felipe Arias    */
/**********************************/

void setup ()                             //definimos los pines de salida
{
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
}

void loop ()
{
  analogWrite(6, (analogRead(A0) / 4));   //salida color Rojo
  analogWrite(3, (analogRead(A1) / 4));   //salida color Verde
  analogWrite(5, (analogRead(A2) / 4));   //salida color Azul
}

Conceptos clave

Hardware libre

Se llama hardware libre o hardware de código abierto a aquellos dispositivos de hardware cuyas especificaciones y diagramas esquemáticos son de acceso público y generalmente de forma gratuita.

Tarjeta Innobot

Es la unidad de control del robot Innobot, pero esta también se puede utilizar para controlar circuitos electrónicos a través de sus diferentes entradas y salidas. Esta tarjeta esta basada en la tarjeta Arduino Leonardo, por lo tanto, tiene sus mismas funciones mas muchas otras agregadas en Pygmalion.

Las partes principales de la tarjeta Innobot son:

  • Los pines digitales sirven entre otras cosas, para leer pulsadores o para prender leds.
  • Las entradas analógicas sirven para leer potenciómetros o en general voltajes que varíen entre 0 y 5 voltios.
  • Los pines de potencia sirven para alimentar el circuito que pongamos en la protoboard.
  • Las borneras para motores M1, M2… M5 sirven para conectar motores y motorreductores de 6V.
  • Las conexiones para sensores J1, J2… J9 sirven para conectar diferentes sensores como el sensor de línea, de ultrasonido, etc. Las conexiones J7, J8 y J9 utilizan protocolo de comunicación I2C.

Arduino UNO

Es una plataforma de hardware libre, que podemos programar para que controle un circuito electrónico. Las partes principales de la tarjeta son:

Entrada y salida digital

Son las que utilizan señales con solo dos estados posibles.

  • CONEXIÓN BLUETOOTH
  • 1 – 0
  • Alto – Bajo
  • Encendido – Apagado

Entrada y salida analógica

Son las que utilizan señales que pueden variar entre un valor mínimo (normalmente 0) y un valor máximo.

Led RGB

Es un led con 3 ánodos para los tres colores primarios (rojo, verde y azul de sus siglas en ingles). Al variar la cantidad de corriente que entra por cada uno         de sus ánodos, se pueden crear diferentes colores. Los 3 ánodos tienen un cátodo en común.

Protoboard

Placa donde se monta y prueba el funcionamiento de los circuitos electrónicos antes de montarlos y soldarlos a la tarjeta PCB.

Abrir chat
¿Necesitas ayuda?
Hola
¿En qué podemos ayudarte? ¿Necesitas más información?
Powered by