SIK Experiment Guide for the Arduino 101/Genuino 101 Board (Spanish)

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - Basic Red 5mm

COM-09590

$0.45

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en el siguiente tutorial:

Diodos emisores de luz: obtenga más información sobre los LED.

Presentación del LED

Un diodo emisor de luz (LED) solo dejará pasar corriente en una dirección. Imagine el LED como una calle de una sola dirección. Cuando la corriente fluye a través del LED, se enciende. Si observa el LED, verá que los pines tienen diferentes longitudes. La patilla larga es el "ánodo", que es por donde entra la corriente en el LED. Esta patilla siempre debe conectarse a la fuente de corriente. La patilla más corta es el "cátodo", que es por donde sale la corriente. La patilla corta siempre debe conectarse a tierra.

Los LED son delicados en lo que se refiere a la cantidad de corriente que se puede aplicar. Si se aplica demasiada corriente, el LED se puede fundir. Para limitar la cantidad de corriente que pasa a través de los LED, utilizamos una resistencia en línea con la fuente de alimentación y la patilla larga del LED; esto se denomina resistencia limitadora de corriente. Con la placa 101, debe usar una resistencia de 100 ohmios. Hemos incluido una bolsa de resistencias en el kit solo por esta razón.

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado y la tabla de conexión siguientes para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección. Los componentes polarizados están resaltados con un triángulo de advertencia amarillo en la tabla de abajo.

**Tenga en cuenta lo siguiente: Preste especial atención a los LED. El lado negativo del LED es la patilla corta, marcada con un borde plano. **

Los componentes como las resistencias deben tener sus patillas dobladas en un ángulo de 90° para encajar correctamente en las tomas de la placa de pruebas También puede acortar las patillas para que sea más fácil trabajar con ellas en la placa de pruebas.

Diagrama de cableado del experimento

¿Tiene problemas para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el primer boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 1; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_01 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_01)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit for the Arduino / Genuino 101
Example sketch 01

BLINKING AN LED

Turn an LED on for one second, off for one second,
and repeat forever.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn about Arduino.
*/

//The setup function runs once upon your Arduino being powered or once upload is          //complete.

void setup()
{
  //set pin 13 to OUTPUT
  pinMode(13, OUTPUT);
}

//The loop function runs from the top down and repeats itself until you upload new        //code or power down your Arduino
void loop()
{
  //Turn pin 13 HIGH (ON).
  digitalWrite(13, HIGH);   

  //wait 1000 milliseconds (1 second)
  delay(1000);              

  //Turn pin 13, LOW (OFF)
  digitalWrite(13, LOW);    

  //wait 1000 milliseconds
  delay(1000);              
}

Código a tener en cuenta

pinMode(13, OUTPUT);

Antes de poder utilizar uno de los pines de la placa 101, debe indicar a la placa si se trata de una ENTRADA o una SALIDA. Para hacer esto, utilizamos una función integrada denominada pinMode().

digitalWrite(13, HIGH);

Si utiliza un pin como una SALIDA, puede indicar que sea ALTA (salida de 3,3 voltios) o BAJA (salida de 0 voltios).

Lo que debería ver

Debería ver el LED parpadear. Si no es así, asegúrese de que ha montado el circuito correctamente y ha verificado y cargado código en la placa o consulte la sección Solución de problemas.

Solución de problemas

El programa no se carga

Esto a veces sucede; la causa más probable es que se haya confundido un puerto serie. Puede cambiarlo en Tools > Serial Port > (Herramientas > Puerto de serie >)

Además, si se produce un error de tiempo de espera o el IDE no puede encontrar la placa 101, pruebe a pulsar el botón de reinicio maestro de la placa 101, espere unos 10 segundos y vuelva a cargar el boceto.

Sigue sin funcionar

Un circuito roto no tiene gracia. Envíenos un correo electrónico y le responderemos en cuanto sea posible: techsupport@sparkfun.com

Experimento 2: Leer un potenciómetro

Introducción

En este circuito trabajará con un potenciómetro. Aprenderá a utilizar un potenciómetro para controlar la frecuencia de parpadeo de un LED; para ello, realizará una lectura de un sensor y la guardará como una variable; luego la usará como el tiempo de retardo.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x LED
1x resistencia de 100 Ω
7x cables puente
1x potenciómetro

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Trimpot 10K Ohm with Knob

COM-09806

$1.05

6

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - Basic Red 5mm

COM-09590

$0.45

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en el siguiente tutorial:

Conversión analógico-digital

Presentación del potenciómetro

Un potenciómetro es un sensor analógico que basa su funcionamiento en la resistencia. Este dispositivo varía su resistencia interna en función de la rotación del mando. El potenciómetro tiene un divisor de tensión interno que le permite leer el cambio de la tensión en el pin central con un microcontrolador (la placa 101). Para conectar el potenciómetro, conecte los dos pines exteriores a una fuente de alimentación (3,3 V en este circuito) y a tierra. No importa el lugar en el que se conecte cada uno, siempre que uno se conecte a la alimentación y el otro a tierra. El pin central se conecta a un pin de entrada analógica para que la placa 101 pueda medir el cambio de la tensión. Cuando gire el mando, la lectura del sensor cambiará.

**Nota: El potenciómetro incluido en el kit tiene tres marcas que le ayudarán a saber en qué fila de la placa de pruebas se conectan los pines. **

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado y la tabla de conexión siguientes para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección. Los componentes polarizados están resaltados con un triángulo de advertencia amarillo en la tabla.

Diagrama de cableado del experimento

¿Tiene problemas para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 2; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_02 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_02)

**Copie y pegue el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre. **

language:cpp
/* SparkFun Inventor's Kit
Example sketch 02

POTENTIOMETER

  Measure the position of a potentiometer and use it to
  control the blink rate of an LED. Turn the knob to make
  it blink faster or slower!

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn about Arduino.
*/

//Create global variables (variables that can be used anywhere in our sketch)

// Here we're creating a variable called "sensorPin" of type "int"
// and initializing it to have the value "0," which is the analog input pin the pot is     //conected to.
int sensorPin = 0;    

// Variable for storing the pin number that the LED is connected to                 
int ledPin = 13;      

// this function runs once when the sketch starts up
void setup()
{
  //set ledPin (13) as an OUTPUT
  pinMode(ledPin, OUTPUT);
}

// this function runs repeatedly after setup() finishes
void loop()
{

  //create a local variable (variable that can only be used inside of loop() to store       //a sensor value called sensorValue
  int sensorValue;

  //use the analogRead() function to read sensorPin and store the value in sensorValue
  sensorValue = analogRead(sensorPin);    

  // Turn the LED on
  digitalWrite(ledPin, HIGH);     

  delay(sensorValue);             

  // Turn the LED off
  digitalWrite(ledPin, LOW);      

 //delay for the value of sensorValue
  delay(sensorValue);             

  //loop back to the top
}

Código a tener en cuenta

int sensorValue;

Una "variable" es un marcador de posición para los valores que pueden cambiar en el código. Debe introducir (o "declarar") variables antes de utilizarlas; aquí se está declarando una variable denominada sensorValue, de tipo "int" (entero). No olvide que los nombres de variables son sensibles mayúsculas y minúsculas.

sensorValue = analogRead(sensorPin);

Utilice la función analogRead() para leer el valor en el pin analógico. analogRead() obtiene un parámetro, el pin analógico que desea usar ("sensorPin"), y devuelve un número ("sensorValue") entre 0 (0 voltios) y 1023 (3,3 voltios).

delay(sensorValue);

Los microcontroladores son muy rápidos y pueden ejecutar miles de líneas de código por segundo. Para reducir la velocidad a fin de poder ver lo que está haciendo, insertaremos retrasos en el código. delay() cuenta en milisegundos; hay 1000 ms en un segundo.

Lo que debería ver

El LED debería parpadear más rápido o más lento de acuerdo con el potenciómetro. Si no funciona, asegúrese de que ha montado el circuito correctamente y ha verificado y cargado código en la placa o consulte la sección Solución de problemas.

Solución de problemas

Funciona de manera esporádica

Esto se debe probablemente a una conexión deficiente con los pines del potenciómetro. Para solucionarlo, apriete el potenciómetro o mueva el circuito del potenciómetro a otro lugar en la placa de pruebas.

Sigue sin funcionar

Compruebe que no ha conectado accidentalmente el contacto deslizante (pin central), la resistencia en el potenciómetro, al pin digital 0 en lugar de al pin analógico 0 (la fila de pines debajo de los pines de alimentación).

El LED no se enciende

El LED solo funciona en una dirección. Vuelva a comprobar las conexiones.

Experimento 3: Controlar un LED RGB

Introducción

¿Sabe que es más divertido que un LED que parpadea? Un LED que cambia de color. En este circuito, aprenderá a utilizar un LED RGB para crear combinaciones únicas de colores. En función de lo brillante que sea cada diodo, se puede conseguir casi cualquier color.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x LED RGB de cátodo común
3x resistencias de 100 Ω
6x cables puente

¿No tiene el 101 SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - RGB Clear Common Cathode

COM-00105

$2.25

3

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Presentación del LED rojo, verde y azul (RGB)

El LED rojo, verde y azul (RGB) consiste en 3 LED en uno. El RGB tiene cuatro pines y los tres más cortos controlan un color individual: rojo, verde o azul. El pin más largo del RGB es el pin a tierra común. Puede crear un LED de color personalizado activando y desactivando diferentes colores para combinarlos. Por ejemplo, si activa el pin rojo y verde, el RGB se iluminará en amarillo.

Pero, ¿a qué color corresponde cada pin? Sostenga el RGB de manera que el pin más largo (a tierra común) esté alineado a la izquierda, como se muestra en el siguiente gráfico. Los pines son los siguientes, de izquierda a derecha: color rojo, a tierra, color verde y color azul.

**Nota: Cuando se conectan los cables del RGB, cada pin de color necesitará una resistencia limitadora de corriente en línea con el pin de la placa 101 que planea utilizar para controlarlo, como con cualquier LED estándar. **

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado y la tabla de conexión siguientes para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección. Los componentes polarizados están resaltados con un triángulo de advertencia amarillo en la tabla de abajo.

Diagrama de cableado del experimento

¿Tiene problemas para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 3; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_03 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_03)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 03

RGB LED

Make an RGB LED display a rainbow of colors!

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn about the Arduino.
*/

//create variables for pin numbers. We are making them constants here, because they       //never change.
const int RED_PIN = 5;
const int GREEN_PIN = 6;
const int BLUE_PIN = 9;

// How fast we plan to cycle through colors in milliseconds
int DISPLAY_TIME = 10;  

void setup()
{
//set the three pin variables as outputs
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
}

void loop()
{
// We've written a custom function called mainColors() that steps
// through all eight of these colors. We're only "calling" the
// function here (telling it to run). The actual function code
// is further down in the sketch.
mainColors();

}

// Here's the mainColors() custom function we've written.
void mainColors()
{
// Off (all LEDs off):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);

//wait 1 second
delay(1000);

// Red (turn just the red LED on):
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);

//wait 1 seconds
delay(1000);

// Green (turn just the green LED on):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);

//wait 1 second
delay(1000);

// Blue (turn just the blue LED on):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);

//wait 1 second
delay(1000);

// Yellow (turn red and green on):
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);

//wait 1 second
delay(1000);

// Cyan (turn green and blue on):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);

//wait 1 second
delay(1000);

// Purple (turn red and blue on):
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);

//wait 1 second
delay(1000);

// White (turn all the LEDs on):
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);

//wait 1 second
delay(1000);
}

Código a tener en cuenta

language:cpp
for (x = 0; x < 768; x++)
{}

El bucle for() se utiliza para repetir una acción un número de veces en un intervalo, y ejecuta repetidamente el código entre corchetes {}. Aquí la variable "x" comienza en 0, termina en 767, y se incrementa de uno en uno ("x++").

language:cpp
if (x <= 255)
{}
else
{}

Las instrucciones "If / else" se utilizan para establecer opciones en los programas. Se evalúa la instrucción entre paréntesis (); si es correcta, el código dentro de los primeros corchetes {} se ejecutará. Si no es correcta, se ejecutará el código dentro de los segundos corchetes {}.

Lo que debería ver

Debe ver que el LED se enciende, pero esta vez con nuevos y divertidos colores. Si no es así, asegúrese de que ha montado el circuito correctamente y ha verificado y cargado código en la placa o consulte la sección Solución de problemas.

Solución de problemas

El LED permanece oscuro o muestra un color incorrecto

Como los cuatro pines del LED están muy próximos físicamente, es bastante fácil colocar alguno en el lugar equivocado. Vuelva a comprobar que cada pin está en el lugar correcto.

Se enciende de color rojo

El diodo rojo del LED RGB puede ser un poco más brillante que los otros dos. Para equilibrar los colores, utilice una resistencia más alta.

Experimento 4: Controlar varios LED

Introducción

Ahora que ha conseguido que el LED parpadee, ha llegado el momento de darle un poco de emoción al asunto: vamos a conectar seis LED a la vez. También haremos una pequeña prueba de la placa 101 mediante la creación de varias secuencias de iluminación. Este experimento es perfecto para comenzar a practicar con la escritura de sus propios programas y hacerse una idea de cómo funciona la placa 101.

Junto con el control de los LED, aprenderá algunos trucos de programación que mantendrán el código limpio y ordenado.

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
6x LED
6x resistencias de 100 Ω
7x cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - Basic Red 5mm

COM-09590

$0.45

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado y la tabla de conexión siguientes para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 4; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_04 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_04)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 04

MULTIPLE LEDs

  Make six LEDs dance. Dance LEDs, dance!

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

// To keep track of all the LED pins, we'll use an "array."
// An array lets you store a group of variables, and refer to them
// by their position, or "index." Here we're creating an array of
// six integers, and initializing them to a set of values:
int ledPins[] = {4,5,6,7,8,9};

void setup()
{
  //create a local variable to store the index of which pin we want to control
  int index;

  // For the for() loop below, these are the three statements:

  //   1\. index = 0;    Before starting, make index = 0.
  //   2\. index <= 5;   If index is less or equal to 5, run the following code
  //   3\. index++   Putting "++" after a variable means "add one to it".

  // When the test in statement 2 is finally false, the sketch
  // will continue.

  // This for() loop will make index = 0, then run the pinMode()
  // statement within the brackets. It will then do the same thing
  // for index = 2, index = 3, etc. all the way to index = 5.

  for(index = 0; index <= 5; index++)
  {
    pinMode(ledPins[index],OUTPUT);
  }
}

void loop()
{
  // This loop() calls functions that we've written further below.
  // We've disabled some of these by commenting them out (putting
  // "//" in front of them). To try different LED displays, remove
  // the "//" in front of the ones you'd like to run, and add "//"
  // in front of those you don't to comment out (and disable) those
  // lines.

  // Light up all the LEDs in turn
  oneAfterAnotherNoLoop();  

  // Same as oneAfterAnotherNoLoop, but less typing
  //oneAfterAnotherLoop();  

  // Turn on one LED at a time, scrolling down the line
  //oneOnAtATime();         

  // Light the LEDs middle to the edges                           
  //pingPong();             

  // Chase lights like you see on signs
  //marquee();              

  // Blink LEDs randomly
  //randomLED();            
}

/*
oneAfterAnotherNoLoop()
This function will light one LED, delay for delayTime, then light
the next LED, and repeat until all the LEDs are on. It will then
turn them off in the reverse order.
*/

void oneAfterAnotherNoLoop()
{
// time (milliseconds) to pause between LEDs
  int delayTime = 100;

  // turn all the LEDs on:

  digitalWrite(ledPins[0], HIGH);  //Turns on LED #0 (pin 4)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[1], HIGH);  //Turns on LED #1 (pin 5)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[2], HIGH);  //Turns on LED #2 (pin 6)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[3], HIGH);  //Turns on LED #3 (pin 7)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[4], HIGH);  //Turns on LED #4 (pin 8)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[5], HIGH);  //Turns on LED #5 (pin 9)
  delay(delayTime);                //wait delayTime milliseconds

  // turn all the LEDs off:

  digitalWrite(ledPins[5], LOW);   //Turn off LED #5 (pin 9)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[4], LOW);   //Turn off LED #4 (pin 8)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[3], LOW);   //Turn off LED #3 (pin 7)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[2], LOW);   //Turn off LED #2 (pin 6)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[1], LOW);   //Turn off LED #1 (pin 5)
  delay(delayTime);                //wait delayTime milliseconds
  digitalWrite(ledPins[0], LOW);   //Turn off LED #0 (pin 4)
  delay(delayTime);                //wait delayTime milliseconds  
}

/*
oneAfterAnotherLoop()

This function does exactly the same thing as oneAfterAnotherNoLoop(),
but it takes advantage of for() loops and the array to do it with
much less typing.
*/

void oneAfterAnotherLoop()
{
  int index;
  int delayTime = 100; // milliseconds to pause between LEDs
                       // make this smaller for faster switching

  // Turn all the LEDs on:

  // This for() loop will step index from 0 to 5
  // (putting "++" after a variable means add one to it)
  // and will then use digitalWrite() to turn that LED on.

  for(index = 0; index <= 5; index++)
  {
    digitalWrite(ledPins[index], HIGH);
    delay(delayTime);                
  }                                  

  // Turn all the LEDs off:

  // This for() loop will step index from 5 to 0
  // (putting "--" after a variable means subtract one from it)
  // and will then use digitalWrite() to turn that LED off.

  for(index = 5; index >= 0; index--)
  {
    digitalWrite(ledPins[index], LOW);
    delay(delayTime);
  }               
}

/*
oneOnAtATime()

This function will step through the LEDs,
lighting only one at at time.
*/

void oneOnAtATime()
{
  int index;
  int delayTime = 100; // milliseconds to pause between LEDs
                       // make this smaller for faster switching

  // step through the LEDs, from 0 to 5

  for(index = 0; index <= 5; index++)
  {
    digitalWrite(ledPins[index], HIGH);  // turn LED on
    delay(delayTime);                    // pause to slow down
    digitalWrite(ledPins[index], LOW);   // turn LED off
  }
}

/*
pingPong()

This function will step through the LEDs,
lighting one at at time in both directions.
*/

void pingPong()
{
  int index;
  int delayTime = 100; // milliseconds to pause between LEDs
                       // make this smaller for faster switching

  // step through the LEDs, from 0 to 5

  for(index = 0; index <= 5; index++)
  {
    digitalWrite(ledPins[index], HIGH);  // turn LED on
    delay(delayTime);                    // pause to slow down
    digitalWrite(ledPins[index], LOW);   // turn LED off
  }

  // step through the LEDs, from 5 to 0

  for(index = 5; index >= 0; index--)
  {
    digitalWrite(ledPins[index], HIGH);  // turn LED on
    delay(delayTime);                    // pause to slow down
    digitalWrite(ledPins[index], LOW);   // turn LED off
  }
}

/*
marquee()

This function will mimic "chase lights" like those around signs.
*/

void marquee()
{
  int index;
  int delayTime = 200; // milliseconds to pause between LEDs
                       // Make this smaller for faster switching

  // Step through the first four LEDs
  // (We'll light up one in the lower 3 and one in the upper 3)

  for(index = 0; index <= 2; index++) // Step from 0 to 3
  {
    digitalWrite(ledPins[index], HIGH);    // Turn a LED on
    digitalWrite(ledPins[index+3], HIGH);  // Skip four, and turn that LED on
    delay(delayTime);                      // Pause to slow down the sequence
    digitalWrite(ledPins[index], LOW);     // Turn the LED off
    digitalWrite(ledPins[index+3], LOW);   // Skip four, and turn that LED off
  }
}

/*
randomLED()

This function will turn on random LEDs. Can you modify it so it
also lights them for random times?
*/

void randomLED()
{
  int index;
  int delayTime;

  // The random() function will return a semi-random number each
  // time it is called. See http://arduino.cc/en/Reference/Random
  // for tips on how to make random() even more random.

  index = random(5);    // pick a random number between 0 and 5
  delayTime = 100;

  digitalWrite(ledPins[index], HIGH);  // turn LED on
  delay(delayTime);                    // pause to slow down
  digitalWrite(ledPins[index], LOW);   // turn LED off
}

Código a tener en cuenta

int ledPins[] = {4,5,6,7,8,9};

Cuando tiene que gestionar una gran cantidad de variables, una "matriz" es una forma práctica para agruparlas. Aquí crearemos una matriz de enteros, denominada ledPins, con seis elementos. Se hace referencia a cada elemento por su índice. El primer elemento es el índice de [0].

digitalWrite(ledPins[0], HIGH);

Puede hacer referencia a los elementos de una matriz por su posición. El primer elemento se encuentra en la posición 0, el segundo en la posición 1, etc. Puede hacer referencia a un elemento mediante "ledPins[x]", donde x es la posición. Aquí creamos un pin digital 4 con valor ALTO, ya que el elemento de la matriz en la posición 0 es "4".

index = random(5);

Los ordenadores prefieren seguir la misma pauta cada vez que se ejecutan. No obstante, es posible que desee hacer cosas aleatoriamente, como simular el lanzamiento de un dado. La función random() es un buen método para conseguir esto. Consulte http://arduino.cc/en/reference/random para obtener más información.

Lo que debería ver

Esto es similar al experimento 1, pero en vez de un LED, debe ver todos los LED parpadear. Si no es así, asegúrese de que ha montado el circuito correctamente y ha verificado y cargado código en la placa o consulte la sección Solución de problemas.

Solución de problemas

Algunos LED no se iluminan

Es fácil insertar un LED al revés. Compruebe los LED que no funcionan y asegúrese de que están en la orientación correcta.

Funcionan de manera irregular

Con ocho cables, es bastante fácil que se mezclen. Vuelva a comprobar que el primer LED está conectado al pin 4, el siguiente al pin posterior, y así sucesivamente.

Empezar de cero

Es fácil conectar incorrectamente un cable sin darse cuenta. A menudo, lo mejor es extraerlos todos y volver a empezar de cero en lugar de buscar el problema.

Experimento 5: Leer un pulsador

Introducción

Hasta ahora, nos hemos centrado principalmente en las salidas. Ahora vamos a ver las entradas. En el experimento 2, hemos utilizado una entrada analógica para leer el potenciómetro. En este experimento, vamos a leer una de las entradas más comunes y sencillas, un pulsador, mediante una entrada digital. La usaremos para pasar por los diferentes colores del RGB.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x LED RGB
3x resistencia de 100 Ω
8x cables puente
1x pulsador
1x resistencias 10K

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - RGB Clear Common Cathode

COM-00105

$2.25

3

Momentary Pushbutton Switch - 12mm Square

COM-09190

$0.55

4

Favorited Favorite 53

Resistor 10K Ohm 1/6th Watt PTH - 20 pack

COM-11508

$0.95

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este tutorial, le recomendamos que se familiarice con los conceptos en los siguientes tutoriales:

Presentación del pulsador

Un pulsador momentáneo cierra o completa el circuito solo mientras está pulsado. El pulsador tiene cuatro pines, organizados en dos conjuntos de dos pines. Cuando presiona el pulsador y se escucha un "clic", el pulsador conecta los dos conjuntos de pines y permite que la corriente fluya a través del circuito.

¿Cómo puede saber qué pines están emparejados? Los pulsadores incluidos en este kit solo encajan en la muesca de la placa de pruebas en una dirección. Tras encajar el pulsador firmemente en la placa de pruebas (a través de la muesca), los pines se emparejan horizontalmente. Por un lado, se conectan los pines hacia la parte superior de la placa de pruebas y, por otro lado, se conectan los pines hacia el pulsador de la placa de pruebas.

Nota: no todos los pulsadores comparten este formato de pines. Consulte la hoja de datos de su pulsador específico para determinar qué pines están emparejados.

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado y la tabla de conexión siguientes para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Entrada digital

Anteriormente hemos utilizado pines analógicos para la entrada; ahora usaremos pines digitales. Ya que los pines digitales solo conocen las señales ALTO y BAJO, son perfectos para conectar pulsadores e interruptores que solo tengan estados de "encendido" y "apagado".

Conectaremos un lado del pulsador a tierra y el otro lado a un pin digital. Cuando presione el pulsador, el pin se conectará a tierra y, por lo tanto, se leerá "BAJO" en la placa Arduino.

Pero, ¿qué sucede cuando no se presiona el pulsador? En este estado, el pin no está conectado a nada, a esto lo denominamos "estado flotante". ¿Cuál será el estado que se leerá en el pin? ¿ALTO o BAJO? Es difícil de decir, porque no hay ninguna conexión sólida ni a la red de 3,3 V ni a tierra. El pin puede tener cualquier de estos dos valores.

Para solucionar este problema, vamos a conectar una pequeña resistencia (10 K o 10.000 ohmios) entre el pin de señal y la línea de 3,3 V. Esta resistencia "pullup" garantizará que cuando NO esté presionando el pulsador, el pin tendrá una débil conexión a la línea de 3,3 voltios y, por tanto, se leerá ALTO.

Avanzado: Cuando se familiarice con las resistencias pullup y sepa cuándo son necesarias, puede activar las resistencias pullup internas en el procesador ATmega en Arduino. Consulte http://arduino.cc/en/Tutorial/DigitalPins para obtener más información.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 5; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_05 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_05)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 05

PUSH BUTTONS

  Use pushbuttons for digital input

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn about the Arduino.

*/

// First we'll set up constants for the pin numbers.
// This will make it easier to follow the code below.

 // pushbutton pin
 const int buttonPin = 3;

 //RGB LED pins
 const int redPin = 11;    
 const int greenPin = 10;
 const int bluePin = 9;

//create a variable to store a counter and set it to 0
int counter = 0;
void setup()
{
  // Set up the pushbutton pins to be an input:
  pinMode(buttonPin, INPUT);

  // Set up the RGB pins to be an outputs:
  pinMode(redPin, OUTPUT);  
  pinMode(greenPin,OUTPUT);
  pinMode(bluePin,OUTPUT);
}

void loop()
{
 // local variable to hold the pushbutton states
  int buttonState;  

  //read the digital state of buttonPin with digitalRead() function and store the           //value in buttonState variable
  buttonState = digitalRead(buttonPin);

  //if the button is pressed increment counter and wait a tiny bit to give us some          //time to release the button
  if (buttonState == LOW) // light the LED
  {
    counter++;
    delay(150);
  }

  //use the if satement to check the value of counter. If counter is equal to 0 all         //pins are off
  if(counter == 0)
  {
   digitalWrite(redPin,LOW);
   digitalWrite(greenPin,LOW);
   digitalWrite(bluePin,LOW);
  }

  //else if counter is equal to 1, redPin is HIGH
  else if(counter == 1)
  {
   digitalWrite(redPin,HIGH);
   digitalWrite(greenPin,LOW);
   digitalWrite(bluePin,LOW);
  }

  //else if counter is equal to 2 greenPin is HIGH
  else if(counter ==2)
  {
   digitalWrite(redPin,LOW);
   digitalWrite(greenPin,HIGH);
   digitalWrite(bluePin,LOW);
  }

  //else if counter is equal to 3 bluePin is HIGH
  else if(counter ==3)
  {
   digitalWrite(redPin,LOW);
   digitalWrite(greenPin,LOW);
   digitalWrite(bluePin,HIGH);
  }

  //else reset the counter to 0 (which turns all pins off)
  else
  {
   counter =0;
  }
}

Código a tener en cuenta

pinMode(buttonPin, INPUT);

Los pines digitales se pueden utilizar tanto como entradas y salidas. Antes de hacerlo, necesita indicar a la placa Arduino la dirección que se seguirá.

buttonState = digitalRead(buttonPin);

Para leer una entrada digital, utilice la función digitalRead(). Devolverá el valor ALTO si hay una alimentación de 3,3 V en el pin o BAJO si hay una alimentación de 0 V en el pin.

if (button1State == LOW)

Ya que hemos conectado el pulsador a tierra, se leerá BAJO cuando se presione. Aquí estamos usando el operador de "equivalencia" ("==") para ver si el pulsador está presionado.

Lo que debería ver

Debe ver el LED encendido si presiona cualquier pulsador y apagado si presiona ambos pulsadores. (Vea el código para averiguar el motivo). Si no funciona, asegúrese de que ha montado el circuito correctamente y ha verificado y cargado código en la placa; o consulte la sección Solución de problemas.

Solución de problemas

No se enciende ninguna luz

El pulsador es cuadrado y, debido a esto, es fácil colocarlo de la forma incorrecta. Gire el pulsador 90 grados y observe si funciona.

Demasiado básico

No se preocupe; estos circuitos se han simplificado al máximo para que sea sencillo jugar con los componentes, pero en cuanto los combine todos, el límite es su imaginación.

Experimento 6: Leer un interruptor SPDT

Introducción

En el experimento anterior ha utilizado un pulsador como entrada digital. En este experimento va a explorar otra entrada digital, el interruptor SPDT (monopolar de dos posiciones). Podrá utilizar este interruptor para seleccionar cuál de los dos LED parpadeará.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
2x LED (1 rojo, 1 amarillo)
2x resistencia de 100 Ω
8x cables puente
1x interruptor SPDT

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Mini Power Switch - SPDT

COM-00102

$1.60

Favorited Favorite 41

LED - Basic Red 5mm

COM-09590

$0.45

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este tutorial, le recomendamos que se familiarice con los conceptos en los siguientes tutoriales:

Presentación del interruptor monopolar de dos posiciones (SPDT)

El interruptor monopolar de dos posiciones (SPDT) tiene un pin común en el centro y otros dos pines que, en función de la ubicación del interruptor, se conectan al pin común (central) o no. Para leer el interruptor de la misma forma que un pulsador, debe conectar el pin común a un pin digital GPIO (entrada/salida de propósito general) en la placa 101 y el resto de pines a una línea de 3,3 V y a tierra. No importa el orden de conexión de los pines. Cuando mueva el interruptor, el valor del pin común será ALTO (conectado a una línea de 3,3 V) o BAJO (conectado a tierra).

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado y la tabla de conexión siguientes para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 6; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_06 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_06)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 06

SPDT Switch

Use a Single Pole - Double Throw Switch (SPDT) to select an LED to blink

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

// Create constants for the pins we will be using
const int switchPin = 3;  
const int led1Pin = 12;  
const int led2Pin =  13;    

void setup()
{
  // Set up the switch pins to be an input:
  pinMode(switchPin, INPUT);

  // Set up the LED pins to be an output:
  pinMode(led1Pin,OUTPUT);    
  pinMode(led2Pin,OUTPUT);
}

void loop()
{
  // variables to hold the switch state
  int switchVal;  

  // Since a switch has only two states, either HIGH (3.3V)
  // or LOW (GND) there is no way for you to have a floating point situation so there       //is no need for a pulldown resistor.

  //store the switch value to the switchVal variable
  switchVal = digitalRead(switchPin);

 //if switchVal is HIGH blink led1Pin
 if(switchVal == HIGH)
 {
   digitalWrite(led1Pin,HIGH);
   delay(500);
   digitalWrite(led1Pin,LOW);
   delay(500);
 }
 //else blink led2Pin
 else
 {
   digitalWrite(led2Pin,HIGH);
   delay(500);
   digitalWrite(led2Pin,LOW);
   delay(500);
 }
}

Código a tener en cuenta

pinMode(switchPin, INPUT);

Los pines digitales se pueden utilizar tanto como entradas y salidas. Antes de hacerlo, necesita indicar a la placa Arduino 101 la dirección que se seguirá.

switchVal = digitalRead(switchPin);

Para leer una entrada digital, utilice la función digitalRead(). Devolverá el valor ALTO si hay una alimentación de 3,3 V en el pin o BAJO si hay una alimentación de 0 V en el pin.

if (switchVal == LOW)

Ya que hemos conectado el pulsador a tierra, se leerá BAJO cuando se presione. Aquí estamos usando el operador de "equivalencia" ("==") para ver si el pulsador está presionado.

Lo que debería ver

En función del estado del interruptor, parpadeará un LED diferente. Si mueve el interruptor para conectar el pin de señal a la línea de 3,3V (ALTO), parpadeará el LED 1. Si se mueve el interruptor y conecta a tierra el pin de señal, el LED 2 comenzará a parpadear y el LED 1 se apagará.

Solución de problemas

No se enciende ninguna luz

Los cables del interruptor están uno al lado del otro. Asegúrese de que la conexión de la señal está en el centro y las de tierra y alimentación en los pines exteriores. Si conecta las tomas de tierra y alimentación, la placa se cortocircuitará y se apagará.

Asegúrese de que el LED de alimentación está encendido. Si está apagado, retire el cable de señal del pin 3 y observe si hay algún cambio. Si se produce un cortocircuito, la placa 101 se apagará automáticamente para proteger los circuitos. Es posible que tenga que reiniciar el ordenador para poder acceder al puerto serie.

Demasiado básico

No se preocupe; estos circuitos se han simplificado al máximo para que sea sencillo jugar con los componentes, pero en cuanto los combine todos, el límite es su imaginación.

Experimento 7: Leer un fotorresistor

Introducción

En el experimento 2 tuvo que usar un potenciómetro, que varía la resistencia con el control del mando y, a su vez, cambia la tensión que lee el pin de entrada analógica. En este circuito utilizará un fotorresistor, que cambia la resistencia en función de la cantidad de luz que recibe el sensor. Se analizará la luz de la habitación y un LED se encenderá si hay mucha oscuridad y se apagará si hay mucha luz. En otras palabras: va a fabricar una lamparilla.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x LED
1x resistencia de 100 Ω
7x cables puente
1x fotorresistencia
1x resistencia 10K

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Mini Photocell

SEN-09088

$1.60

7

Favorited Favorite 75

Resistor 10K Ohm 1/6th Watt PTH - 20 pack

COM-11508

$0.95

LED - Basic Red 5mm

COM-09590

$0.45

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Presentación del fotorresistor

El fotorresistor cambia su resistencia en función de la luz a la que se expone. Para utilizar la placa 101, tendrá que construir un divisor de tensión con una resistencia de 10.000 ohmios como se muestra en el diagrama de cableado de este experimento. La placa 101 no puede leer los cambios en la resistencia, solo los de tensión. Un divisor de tensión permite convertir un cambio en la resistencia a un valor de tensión correspondiente.

Los divisores de tensión permiten el uso de sensores basados en la resistencia, como el fotorresistor, en un sistema basado en tensión. A medida que explore diferentes sensores, encontrará más basados en la resistencia que solo tienen dos pines (como es el caso de los fotorresistores). Para usarlos con la placa 101, necesitará crear un divisor de tensión como el de este experimento. Para obtener más información acerca de las resistencias en general, consulte nuestro tutorial sobre resistencias y también nuestro tutorial sobre los divisores de tensión.

Nota: asegúrese de que está utilizando la resistencia de 10.000 ohmios en el divisor de tensión con los sensores de este kit. De lo contrario, obtendrá resultados extraños e incoherentes.

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 7; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_07 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_07)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 07

PHOTORESISTOR

  Read a photoresistor (light sensor) to detect "darkness" and turn on an LED when it is "dark" and turn back off again when it is "bright."

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

// As usual, we'll create constants to name the pins we're using.
// This will make it easier to follow the code below.

const int sensorPin = 0;
const int ledPin = 9;

// We'll also set up some global variables for the light level a calibration value and     //and a raw light value
int lightCal;
int lightVal;

void setup()
{
  // We'll set up the LED pin to be an output.
  pinMode(ledPin, OUTPUT);
  lightCal = analogRead(sensorPin);
  //we will take a single reading from the light sensor and store it in the lightCal        //variable. This will give us a prelinary value to compare against in the loop
}

void loop()
{
  //Take a reading using analogRead() on sensor pin and store it in lightVal
  lightVal = analogRead(sensorPin);

  //if lightVal is less than our initial reading (lightCal) minus 50 it is dark and         //turn pin 9 HIGH. The (-50) part of the statement sets the sensitivity. The smaller       //the number the more sensitive the circuit will be to variances in light.
  if(lightVal < lightCal - 50)
  {
    digitalWrite(9,HIGH);
  }

  //else, it is bright, turn pin 9 LOW
  else
  {
    digitalWrite(9,LOW);
  }

}

Código a tener en cuenta

lightCal = analogRead(sensorPin); lightCal es una variable de calibración. La placa 101 obtiene una única lectura del sensor de luz en la configuración y utiliza este valor para compararlo con el valor lightVal del bucle. Este valor no cambia en el bucle, ya que se establece en la función de configuración. Para actualizar este valor, puede pulsar el botón de reinicio, o apagar y encender la placa.

if(lightVal < lightCal -50) Si la variable del valor de luz que se actualiza constantemente en el bucle es inferior al valor de calibración establecido en la configuración menos 50, hay oscuridad y el LED se debe encender. La parte (-50) de esta instrucción es un valor de sensibilidad. Cuanto mayor sea el valor, menos sensible será el circuito; cuanto menor sea el valor, más sensible será a las condiciones de iluminación.

Lo que debería ver

El LED debería encenderse cuando hay más oscuridad y apagarse cuando hay más luz. Ponga la mano sobre el sensor y, a continuación, retírela. Si no funciona, asegúrese de que ha montado el circuito correctamente y que ha verificado y cargado código en la placa. De lo contrario, consulte la sección Solución de problemas.

Solución de problemas

El LED no se enciende

Es posible que haya estado proyectando una sombra sobre el sensor cuando cargaba el código. Asegúrese de que el sensor está expuesto a la luz ambiental de la sala y pulse el botón de reinicio maestro o vuelva a cargar el código. Esto restablecerá el valor de calibración en la configuración.

Sigue sin funcionar

Es posible que haya creado una instrucción lógica incorrectamente. Compruebe el código y ajuste el nivel de sensibilidad un poco más alto o más bajo. Asegúrese de que no hay un punto y coma después de la instrucción if(). Este es un error muy común y difícil de detectar.

Experimento 8: Mezclar colores con el RGB

Introducción

En este circuito trabajará con varios potenciómetros. En el experimento 1 ha utilizado un solo potenciómetro. Ahora vamos a subir el listón y utilizaremos tres. ¿Por qué tres? Va a utilizar cada potenciómetro para controlar el brillo de tres colores (rojo, verde y azul) de un LED RGB a fin de crear interesantes combinaciones con los colores básicos que ha utilizado en el experimento 3.

Saque el pincel y prepárese para pintar un arcoíris.

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x LED RGB de cátodo común
3x resistencia de 100 Ω
15x cables puente
3x potenciómetros

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Trimpot 10K Ohm with Knob

COM-09806

$1.05

6

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - RGB Clear Common Cathode

COM-00105

$2.25

3

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en los siguientes tutoriales:

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado y la tabla de conexión siguientes para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección. Los componentes polarizados están resaltados con un triángulo de advertencia amarillo en la tabla.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 8; para ello, acceda a "SIK Guide Code" (Guía de códigos de SIK) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > SIK Guide Code > Circuit_08 (Archivo > Ejemplos > Guía de códigos de SIK > Circuito_08)

**Copie y pegue el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre. **

language:cpp
/* SparkFun Inventor's Kit
Example sketch 08

POTENTIOMETER

  Measure the position of each potentiometer and map it to
  the red, green and blue values! Then write those values to the RGB LED.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

//create constants for the three analog input pins
const int redPot = 0;
const int greenPot = 1;
const int bluePot = 2;

//create constants for the three RGB pulse width pins
const int redPin = 5;
const int greenPin = 6;
const int bluePin = 9;

//create variables to store the red, green and blue values
int redVal;
int greenVal;
int blueVal;

void setup()
{
  //set the RGB pins as outputs
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop()
{
  //read the three analog input pins and store their value to the color variables
  redVal = analogRead(redPot);
  greenVal = analogRead(greenPot);
  blueVal = analogRead(bluePot);

  //use the map() function to scale the 10 bit (0-1023) analog input value to an 8 bit
  //(0-255) PWM, or analogWrite() signal. Then store the new mapped value back in the
  //color variable

  redVal = map(redVal, 0, 1023, 0, 255);
  greenVal = map(greenVal, 0, 1023, 0, 255);
  blueVal = map(blueVal, 0, 1023, 0, 255);

  // use the analogWrite() function to write the color values to their respective
  // RGB pins.
  analogWrite(redPin, redVal);
  analogWrite(greenPin, greenVal);
  analogWrite(bluePin, blueVal);
}

Código a tener en cuenta

analogWrite(6,233); La función analogWrite se utiliza para controlar la PWM en los pines 9, 6, 5 y 3 de la placa 101. Puede escribir un valor en el rango de 0 a 255, en el que 255 equivale a completamente encendido y 0 equivale a completamente apagado.

lightLevel = map(lightLevel, 0, 1023, 0, 255);

Parámetros

map(value, fromLow, fromHigh, toLow, toHigh)

value: el número que asignar

fromLow: el límite inferior del rango actual del valor

fromHigh: el límite superior del rango actual del valor

toLow: el límite inferior del rango objetivo del valor

toHigh: el límite superior del rango objetivo del valor

Cuando leemos una señal analógica con analogRead(), será un número de 0 a 1023. Pero cuando queremos controlar un pin de PWM con analogWrite(), será un número de 0 a 255. Podemos "adaptar" el rango superior al rango inferior con la función map(). Consulte la página de referencia de asignaciones para obtener más información.

Lo que debería ver

Debería ver que el LED RGB cambia de color cuando enciende los tres potenciómetros. Cada potenciómetro controlará un color determinado (rojo, verde y azul). Cuando se activan todos los potenciómetros hasta el valor máximo, debe ver una luz blanca del RGB. Cuando todos están desactivados, el RGB debe estar completamente apagado. Si no es así, consulte la sección Solución de problemas a continuación.

Solución de problemas

Funciona de manera esporádica

Esto se debe probablemente a una conexión deficiente con los pines del potenciómetro. Para solucionarlo, apriete el potenciómetro o mueva el circuito del potenciómetro a otro lugar en la placa de pruebas.

Sigue sin funcionar

Compruebe que no ha conectado accidentalmente el contacto deslizante (pin central), la resistencia en el potenciómetro, al pin digital 0 en lugar de al pin analógico 0. (La fila de pines debajo de los pines de alimentación).

El LED no se enciende

Los LED solo funcionan en una dirección. Vuelva a comprobar las conexiones.

Experimento 9: Leer un sensor de temperatura

Introducción

Un sensor de temperatura es exactamente lo que indica su propio nombre: un sensor que se utiliza para medir la temperatura ambiente. En este experimento leerá el valor 0-1023 sin procesar del sensor de temperatura, calculará la temperatura real y, a continuación, la imprimirá en el monitor serie. ¿No sabe lo que es el monitor serie? Realice el experimento para averiguarlo.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
3 cables puente
1x sensor de temperatura TMP36

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Temperature Sensor - TMP36

SEN-10988

$1.60

18

Favorited Favorite 79

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Presentación del sensor de temperatura TMP36

El TMP36 es un sensor de temperatura de grados centígrados de precisión y baja tensión. Proporciona una salida de tensión que es linealmente proporcional a la temperatura Celsius. Además, no requiere ninguna calibración externa para proporcionar precisiones típicas de ±1 °C a +25 °C y de ±2 °C en el rango de temperatura de -40 °C a +125 °C. La tensión de salida se puede convertir fácilmente en la temperatura usando el factor de escala de 10 mV/°C.

Si mira la cara plana con texto, el pin central es el pin de señal, el pin izquierdo está conectado a la fuente de alimentación (3,3 V en este tutorial) y el pin derecho se conecta a tierra.

Consejo experto: el TMP36 se parece mucho a un transistor. Pinte un punto con esmalte de uñas en la parte superior del TMP36 para identificarlo fácilmente.

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Tenga en cuenta lo siguiente: El sensor de temperatura solo puede conectarse a un circuito en una dirección. Vea a continuación los pines del sensor de temperatura TMP36.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 9; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_09 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_09)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 07

TEMPERATURE SENSOR

  Use the "serial monitor" window to read a temperature sensor.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.

*/

//analog input pin constant
const int tempPin = 0;

//raw reading variable
int tempVal;

//voltage variable
float volts;

//final temperature variables
float tempC;
float tempF;

void setup()
{
  // start the serial port at 9600 baud
  Serial.begin(9600);
}

void loop()
{
 //read the temp sensor and store it in tempVal
 tempVal = analogRead(tempPin);

 //print out the 10 value from analogRead
 Serial.print("TempVal = ");
 Serial.print(tempVal);

 //print a spacer  
 Serial.print(" **** ");

 //converting that reading to voltage by multiplying the reading by 3.3V (voltage of       //the 101 board)
 volts = tempVal * 3.3;
 volts /= 1023.0;

 //print out the raw voltage over the serial port
 Serial.print("volts: ");
 Serial.print(volts, 3);

 //print out divider
 Serial.print(" **** ");

 //calculate temperature celsius from voltage
 //equation found on the sensor spec.
 tempC = (volts - 0.5) * 100 ;

// print the celcius temperature over the serial port
Serial.print(" degrees C: ");
Serial.print(tempC);

//print spacer
 Serial.print(" **** ");

// Convert from celcius to fahrenheit
tempF = (tempC * 9.0 / 5.0) + 32.0;

//print the fahrenheit temperature over the serial port
Serial.print(" degrees F: ");
Serial.println(tempF);

//wait a bit before taking another reading
delay(1000);
}

Código a tener en cuenta

Serial.begin(9600);

Antes de usar el monitor serie, debe utilizar Serial.begin() para inicializarlo. 9600 es la velocidad en baudios o la velocidad de comunicación. Cuando dos dispositivos se comunican entre sí, ambos deben tener la misma velocidad.

Serial.print(tempC);

El comando Serial.print() es muy inteligente. Puede imprimir casi todo lo que solicite, incluidas las variables de todos los tipos, texto entre comillas (es decir, "cadenas"), etc. Visite http://arduino.cc/en/serial/print para obtener más información.

Serial.println(tempF);

Serial.print() imprimirá todo en la misma línea.

Serial.println() pasará a la siguiente línea. Mediante estos dos comandos juntos, puede crear impresiones de texto y datos fáciles de leer.

Lo que debería ver

Debe poder leer la temperatura que detecta el sensor de temperatura en el monitor serie de IDE de Arduino. Si no funciona, asegúrese de que ha montado el circuito correctamente y que ha verificado y cargado código en la placa. De lo contrario, consulte la sección Solución de problemas.

Ejemplo de lo que debe ver en el monitor serie del IDE de Arduino:

TempVal = 223 **** Voltios: 0,719 **** Grados C: 21,94 **** Grados F: 71,48

TempVal = 224 **** Voltios: 0,723 **** Grados C: 22,26 **** Grados F: 72,06

TempVal = 223 **** Voltios: 0,719 **** Grados C: 21,94 **** Grados F: 71,48

Solución de problemas

No sucede nada

Este programa no tiene ningún indicador de que esté funcionando. Para ver los resultados, debe abrir el monitor serie del IDE de Arduino (instrucciones en la página anterior).

No aparece nada con sentido

Esto sucede porque el monitor serie está recibiendo datos a una velocidad diferente a la esperada. Para corregir esto, haga clic en el cuadro desplegable "*** baud" (*** baudios) y cámbielo a "9600 baud" (9600 baudios).

El valor de la temperatura no cambia

Intente pellizcar el sensor con los dedos para calentarlo o ponga una bolsa de hielo encima para enfriarlo.

El sensor de temperatura está muy caliente

Debe haberlo conectado al revés. Desconecte la placa Arduino inmediatamente, deje que el sensor se enfríe y vuelva a revisar el cableado. Si lo ha hecho lo suficientemente pronto, es probable que el sensor no se haya dañado y pueda funcionar.

Experimento 10: Controlar un servomotor

Introducción

Este experimento sirve de presentación del servomotor, un motor inteligente que puede hacer rotar a una ubicación angular específica. Puede programarlo para que gire a una serie de ubicaciones, recorra todo el rango de movimiento y, a continuación, que vuelva a realizar la misma operación.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x servo
3 cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Servo - Generic (Sub-Micro Size)

ROB-09065

$9.95

13

Favorited Favorite 44

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en el siguiente tutorial:

Modulación por ancho de pulsos (PWM)

Presentación del servomotor

A diferencia del funcionamiento de la mayoría de los motores que giran continuamente, un servomotor puede girar a un ángulo determinado y mantenerse en esa posición hasta que se le indique que gire a un ángulo diferente. Puede controlar el ángulo del servo enviándole un tren de pulsos PWM; la señal de PWM se asigna a un ángulo específico de 0 a 180 grados.

Dentro del servo hay una caja de engranajes conectada a un motor que acciona el eje. También hay un potenciómetro que proporciona información sobre la posición de giro del servo, que a continuación se compara con la señal de PWM entrante. El servo se ajusta en consecuencia para corresponderse con las dos señales.

En este experimento, el servo recibe una alimentación de 5 V a través del cable rojo, está conectado a tierra con el cable negro, y el cable blanco está conectado a un pin GPIO digital en el que puede usar la PWM (9, 6, 5, 3 en la placa 101).

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Conecte los 3 cables puente al cabezal de 3 pines en el servo. Esto facilitará conectar el servo a la placa de pruebas.

Diagrama de cableado del experimento

¿Tiene problemas para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 10; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_10 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_10)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 10

SINGLE SERVO

  Sweep a servo back and forth through its full range of motion.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

//include the servo library
#include   

//create a servo object called servo1
Servo servo1;  

void setup()
{
  //attach servo1 to pin 9 on the Arduino 101
  servo1.attach(9);
}

void loop()
{
  //create a local variable to store the servo's position.
  int position;

  // To control a servo, you give it the angle you'd like it
  // to turn to. Servos cannot turn a full 360 degrees, but you
  // can tell it to move anywhere between 0 and 180 degrees.

  // Change position at full speed:

  // Tell servo to go to 90 degrees
  servo1.write(90);   

  // Pause to get it time to move
  delay(1000);        

  // Tell servo to go to 180 degrees
  servo1.write(180);   

  // Pause to get it time to move
  delay(1000);         

  // Tell servo to go to 0 degrees
  servo1.write(0);     

  // Pause to get it time to move
  delay(1000);         

  // Tell servo to go to 180 degrees, stepping by two degrees
  for(position = 0; position < 180; position += 2)
  {
  // Move to next position
    servo1.write(position);  
     // Short pause to allow it to move
    delay(20);              
  }

  // Tell servo to go to 0 degrees, stepping by one degree
  for(position = 180; position >= 0; position -= 1)
  {
    // Move to next position
    servo1.write(position);
    // Short pause to allow it to move
    delay(20);               
  }
}

Código a tener en cuenta

#include

#include es un comando especial del "preprocesador" que inserta una biblioteca (o cualquier otro archivo) en el boceto. Puede escribir este comando o elegir una biblioteca instalada en el menú "sketch / import library" (Boceto/Importar biblioteca).

Servo servo1;

Cuando se utiliza una biblioteca, se crea lo que se denomina un objeto de dicha biblioteca, al que se asigna un nombre. Este objeto es un objeto de la biblioteca del servo y se denomina servo1. Si se utilizan varios servos, tendrá que asignar un nombre a cada uno de esta manera.

servo1.attach(9);

La biblioteca de servos agrega nuevos comandos que le permiten controlar un servo. Para que Arduino controle un servo, primero debe crear un "objeto" del servo para cada servo (en este ejemplo lo hemos llamado "servo1") y, a continuación, "conectarlo" a un pin digital (en este ejemplo estamos utilizando el pin 9). Piense en esto como la manera que tiene el servo para activar la función pinMode().

servo1.write(180);

Los servos de este kit no giran completamente, pero se puede solicitar que se muevan a una posición específica. Utilizamos el comando write() de la biblioteca del servo para mover el servo un número de grados especificado (de 0 a 180). Recuerde que el servo requiere tiempo para moverse, por lo tanto, asígnele un valor bajo de delay() si es necesario.

Lo que debería ver

Debería ver al servomotor moverse a diferentes ubicaciones a varias velocidades. Si el motor no se mueve, compruebe las conexiones y asegúrese de que ha verificado y cargado el código o consulte la sección Solución de problemas.

Solución de problemas

El servomotor no gira

Incluso con cables de colores es muy fácil conectar un servo al revés. Este podría ser la causa del problema.

Sigue sin funcionar

Un fallo que hemos cometido alguna vez ha sido olvidar conectar la alimentación (cables rojo y negro) a la línea de 5 voltios y a tierra.

Funcionamiento irregular

Si el servo comienza a moverse y, a continuación, da una sacudida, y parpadea una luz en la placa 101, la alimentación que está utilizando no es suficiente. Si utiliza un adaptador de pared en lugar de un USB, el problema debería resolverse.

Experimento 11: Usar un transistor

Introducción

En el experimento anterior, tuvo que trabajar con un servomotor. Ahora, vamos a hacer girar un motor. Para ello, utilizaremos un transistor, que puede gestionar más cantidad de corriente que la placa 101. El transistor se utilizará para encender y apagar un motor, es decir, será un motor intermitente.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x motor reductor 48:1
1x resistencia de 100 Ω
1x transistor NPN
1x diodo 1N4148
7x cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Hobby Gearmotor - 140 RPM (Pair)

ROB-13302

$5.50

6

Transistor - NPN, 50V 800mA (BC337)

COM-13689

$0.55

Favorited Favorite 23

Zener Diode - 5.1V 1W

COM-10301

Retired

Favorited Favorite 10

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en los siguientes tutoriales:

Presentación del transistor

El transistor se puede describir como un pequeño interruptor electrónico. Permite controlar grandes cargas de corriente con una corriente menor sin el riesgo de fundir los componentes sensibles. Un transistor tiene tres pines: un colector, un emisor y una base. En el transistor la corriente solo puede fluir en una dirección, entra a través del colector y sale por el emisor. Para controlar el flujo de la corriente, usted aplica una pequeña corriente a la base. Esta pequeña corriente puede ser digital (encendido o apagado) o analógica (mediante PWM y la función analogWrite()). La corriente mayor reflejará lo que hace la corriente más pequeña.

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Tenga en cuenta lo siguiente: Cuando esté ensamblando el circuito, tenga cuidado de no mezclar el transistor y el sensor de temperatura ya que son prácticamente idénticos. Busque "P2N2222A" en el cuerpo del transistor.

Diagrama de cableado del experimento

¿Tiene problemas para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

¿Qué es un diodo Flyback?

Cuando el motor giratorio de repente se apaga, el campo magnético en su interior se colapsa, lo que genera un pico de tensión. Esto puede dañar el transistor. Para evitar esto, utilizamos un "diodo Flyback", que desvía el pico de tensión "alrededor" del transistor. Conecte el extremo del diodo con la banda (cátodo) a una alimentación de 5 V. Conecte el otro extremo del diodo (ánodo) al cable negro en el motor.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 11; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_11 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_11)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 11

SPINNING A MOTOR

  Use a transistor to spin a motor at different speeds.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

// constant pin for the transistor connected to the motor
const int motorPin = 9;

void setup()
{
  //set motorPin as OUTPUT
  pinMode(motorPin, OUTPUT);
}

void loop()
{
  // Here we've used comments to disable some of the examples.
  // To try different things, uncomment one of the following lines
  // and comment the other ones. See the functions below to learn
  // what they do and how they work.

   motorOnThenOff();
  // motorOnThenOffWithSpeed();
  // motorAcceleration();
}

// This function turns the motor on and off like the blinking LED.
// Try different values to affect the timing.
void motorOnThenOff()
{
  // milliseconds to turn the motor on
  int onTime = 3000;
  // milliseconds to turn the motor off
  int offTime = 3000;

  // turn the motor on (full speed)
  digitalWrite(motorPin, HIGH);
  // delay for onTime milliseconds
  delay(onTime);     
  // turn the motor off
  digitalWrite(motorPin, LOW);  
  // delay for offTime milliseconds
  delay(offTime);               
}

// This function alternates between two speeds.
// Try different values to affect the timing and speed.
void motorOnThenOffWithSpeed()
{
  // between 0 (stopped) and 255 (full speed)
  int Speed1 = 200;
   // milliseconds for speed 1
  int Time1 = 3000;

  // between 0 (stopped) and 255 (full speed)
  int Speed2 = 50;
  // milliseconds to turn the motor off
  int Time2 = 3000;  

  // turns the motor On
  analogWrite(motorPin, Speed1);  
  // delay for onTime milliseconds
  delay(Time1);   
  // turns the motor Off
  analogWrite(motorPin, Speed2);  
  // delay for offTime milliseconds
  delay(Time2);                   
}

// This function slowly accelerates the motor to full speed,
// then back down to zero.
void motorAcceleration()
{
  // milliseconds between each speed step
  int speed;
  int delayTime = 20;

  // accelerate the motor
  for(speed = 0; speed <= 255; speed++)
  {
    // set the new speed
    analogWrite(motorPin,speed);
    // delay between speed steps
    delay(delayTime);               
  }

  // decelerate the motor
  for(speed = 255; speed >= 0; speed--)
  {
    // set the new speed
    analogWrite(motorPin,speed);
    // delay between speed steps
    delay(delayTime);               
  }
}

Lo que debería ver

El motor CC debería girar si se han montado los componentes del circuito correctamente y si ha verificado y cargado el código correcto. Si el circuito no funciona, consulte la sección Solución de problemas.

Solución de problemas

El motor no gira

Si utiliza su propio transistor, vuelva a comprobar con la hoja de datos que la distribución de pines es compatible con el transistor que está utilizando (muchos están invertidos).

Todavía sigue sin funcionar

Si utiliza su propio motor, vuelva a comprobar que funciona con 5 voltios y que no consume demasiada energía.

Sigue sin funcionar

A veces la placa Arduino se desconecta del ordenador. Intente desenchufarla y volver a enchufarla en el puerto USB.

Experimento 12: Usar el controlador del motor

Introducción

En el experimento anterior, tuvo que trabajar con un servomotor. Ahora, vamos a utilizar un motor giratorio. Esto requiere el uso de un transistor, que puede gestionar más cantidad de corriente que la placa 101. Utilizará el transistor para encender y apagar un motor, es decir, será un motor intermitente.

Elementos necesarios

Necesitará los siguientes elementos:

1 placa de pruebas
1 placa Arduino 101 o Genuino 101
1 motor reductor 48:1
1 resistencia de 100 Ω
1 transistor NPN
1 diodo 1N4148
7 cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Hobby Gearmotor - 140 RPM (Pair)

ROB-13302

$5.50

6

Transistor - NPN, 50V 800mA (BC337)

COM-13689

$0.55

Favorited Favorite 23

Zener Diode - 5.1V 1W

COM-10301

Retired

Favorited Favorite 10

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en los siguientes tutoriales:

Presentación del transistor

El transistor se puede describir como un pequeño interruptor electrónico. Le permite controlar grandes cargas de corriente con una corriente menor sin el riesgo de fundir los componentes sensibles. Un transistor tiene tres pines: un colector, un emisor y una base. En el transistor la corriente solo puede fluir en una dirección: entra a través del colector y sale por el emisor. Para controlar el flujo de la corriente, usted aplica una pequeña corriente a la base. Esta pequeña corriente puede ser digital (encendido o apagado) o analógica (mediante PWM y la función analogWrite()). La corriente mayor reflejará lo que hace la corriente más pequeña.

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Tenga en cuenta lo siguiente: Cuando esté desarrollando el circuito, tenga cuidado de no mezclar el transistor y el sensor de temperatura ya que son prácticamente idénticos. Busque "P2N2222A" en el cuerpo del transistor.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

¿Qué es un diodo Flyback?

Cuando el motor giratorio de repente se apaga, el campo magnético en su interior se colapsa, lo que genera un pico de tensión. Esto puede dañar el transistor. Para evitar esto, utilizamos un "diodo Flyback", que desvía el pico de tensión "alrededor" del transistor. Conecte el lado del diodo con la banda (cátodo) a una alimentación de 5 V. Conecte el otro extremo del diodo (ánodo) al cable negro en el motor.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controla el circuito. Abra el código del circuito 11; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_11 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_11)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 11

SPINNING A MOTOR

  Use a transistor to spin a motor at different speeds.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

// constant pin for the transistor connected to the motor
const int motorPin = 9;

void setup()
{
  //set motorPin as OUTPUT
  pinMode(motorPin, OUTPUT);
}

void loop()
{
  // Here we've used comments to disable some of the examples.
  // To try different things, uncomment one of the following lines
  // and comment the other ones. See the functions below to learn
  // what they do and how they work.

   motorOnThenOff();
  // motorOnThenOffWithSpeed();
  // motorAcceleration();
}

// This function turns the motor on and off like the blinking LED.
// Try different values to affect the timing.
void motorOnThenOff()
{
  // milliseconds to turn the motor on
  int onTime = 3000;
  // milliseconds to turn the motor off
  int offTime = 3000;

  // turn the motor on (full speed)
  digitalWrite(motorPin, HIGH);
  // delay for onTime milliseconds
  delay(onTime);     
  // turn the motor off
  digitalWrite(motorPin, LOW);  
  // delay for offTime milliseconds
  delay(offTime);               
}

// This function alternates between two speeds.
// Try different values to affect the timing and speed.
void motorOnThenOffWithSpeed()
{
  // between 0 (stopped) and 255 (full speed)
  int Speed1 = 200;
   // milliseconds for speed 1
  int Time1 = 3000;

  // between 0 (stopped) and 255 (full speed)
  int Speed2 = 50;
  // milliseconds to turn the motor off
  int Time2 = 3000;  

  // turns the motor On
  analogWrite(motorPin, Speed1);  
  // delay for onTime milliseconds
  delay(Time1);   
  // turns the motor Off
  analogWrite(motorPin, Speed2);  
  // delay for offTime milliseconds
  delay(Time2);                   
}

// This function slowly accelerates the motor to full speed,
// then back down to zero.
void motorAcceleration()
{
  // milliseconds between each speed step
  int speed;
  int delayTime = 20;

  // accelerate the motor
  for(speed = 0; speed <= 255; speed++)
  {
    // set the new speed
    analogWrite(motorPin,speed);
    // delay between speed steps
    delay(delayTime);               
  }

  // decelerate the motor
  for(speed = 255; speed >= 0; speed--)
  {
    // set the new speed
    analogWrite(motorPin,speed);
    // delay between speed steps
    delay(delayTime);               
  }
}

Lo que debería ver

El motor CC debería girar si se han montado los componentes del circuito correctamente y si ha verificado y cargado el código correcto. Si el circuito no funciona, consulte la sección Solución de problemas.

Solución de problemas

El motor no gira

Si utiliza su propio transistor, vuelva a comprobar con la hoja de datos que la distribución de pines es compatible con el transistor que está utilizando (muchos están invertidos).

Todavía sigue sin funcionar

Si utiliza su propio motor, vuelva a comprobar que funciona con 5 voltios y que no consume demasiada energía.

Sigue sin funcionar

A veces la placa Arduino se desconecta del ordenador. Intente desenchufarla y volver a enchufarla en el puerto USB.

Experimento 13: Controlador del motor con entradas

Introducción

En el experimento 12 ha utilizado la placa del controlador del motor para controlar la velocidad y dirección de un motor. El objetivo era codificar la dirección y la velocidad del motor. La mayoría de las aplicaciones que usan un motor permiten al usuario controlar la velocidad y la dirección del motor, como lo haría en su propio vehículo. En este experimento vamos a añadir dos entradas y las utilizaremos para controlar la dirección y velocidad del motor.

¿Está preparado para poner el motor en marcha? ¡Comencemos!

Elementos necesarios

Necesitará los siguientes elementos:

1 placa de pruebas
1 placa Arduino 101 o Genuino 101
1 interruptor SPDT
1 potenciómetro 10K
1 placa del controlador del motor SparkFun
1 motor reductor 48:1
20 cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Trimpot 10K Ohm with Knob

COM-09806

$1.05

6

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Hobby Gearmotor - 140 RPM (Pair)

ROB-13302

$5.50

6

Mini Power Switch - SPDT

COM-00102

$1.60

Favorited Favorite 41

SparkFun Motor Driver - Dual TB6612FNG (1A)

ROB-09457

18 Retired

Favorited Favorite 18

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controla el circuito. Abra el código del circuito 13; para ello, acceda a "SIK Guide Code" (Guía de códigos de SIK) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > SIK Guide Code > Circuit_13 (Archivo > Ejemplos > Guía de códigos de SIK > Circuito_13)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 13

SparkFun Motor Controller with Inputs

  Use the inputs to manually set the direction and speed of a motor.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/
 //define the two direction logic pins and the speed / PWM pin
 const int DIR_A = 5;
 const int DIR_B = 4;
 const int PWM = 6;

 //define the input pins
 const int switchPin = 10;
 const int potPin = 0;

 void setup()
 {
  //set all pins as output
  pinMode(DIR_A, OUTPUT);
  pinMode(DIR_B, OUTPUT);
  pinMode(PWM, OUTPUT);
  //set the switchPin as INPUT
  pinMode(switchPin, INPUT);
  }

void loop()
{
//read the value from the potentiometer and divide
//it by 4 to get a 0-255 range. Store the value in
//the speed variable
int speed = analogRead(potPin) / 4;

 //read the value of the switch and store it in the
 //direction variable.

//if the value of direction is HIGH drive forward at
//a speed set by the speed variable, else drive reverse
//at a speed set by the speed variable.
if (digitalRead(switchPin) == HIGH)
{
  forward(speed);
}
else
 {
 reverse(speed);
 }
}

//create a custom function that defines moving forward
//the forward() function accepts one parameter and that is
//the speed at which you want to drive forward (0-255)
 void forward(int spd)
 {
 //motor contoller direction pins set to forward
 digitalWrite(DIR_A, HIGH);
 digitalWrite(DIR_B, LOW);

  //write the speed by using the parameter of spd
 analogWrite(PWM, spd);
  }

//create a custom function that defines moving in reverse
//the reverse() function accepts one parameter and that is
//the speed at which you want to drive in reverse (0-255)
void reverse(int spd)
{
//set motor controller pins to reverse
digitalWrite(DIR_A, LOW);
digitalWrite(DIR_B, HIGH);

 //write the speed by using the parameter of spd
 analogWrite(PWM, spd);
 }

Estas funciones, aparentemente muy complejas, toman un solo valor como parámetro: velocidad. Cada función acepta ese valor y lo aplica a la función analogWrite() dentro de la función personalizada. Las funciones personalizadas son un gran método para limpiar el código y hacerlo más modular y útil en otras aplicaciones. ¡Cuidado! Está a mitad de camino de escribir su propia biblioteca.

Lo que debería ver

Debería poder controlar la dirección del motor al activar el interruptor SPDT y la velocidad con el potenciómetro. Continúe probando ambas entradas para asegurarse de que funcionan y que el motor responde a dichas entradas.

Solución de problemas

El motor gira solo en una dirección

Verifique el cableado del interruptor y verifique también la instrucción if() para asegurarse de que no hay un punto y coma después de la instrucción.

Además, verifique que ha conectado correctamente los cables del pin de espera (3,3 V).

Experimento 14: Usar un zumbador piezoeléctrico

Introducción

En este experimento, salvaremos las diferencias existentes entre el mundo digital y el analógico. Usaremos un zumbador piezoeléctrico que hace un pequeño "clic" cuando se aplica tensión (vamos a probarlo). En sí no es muy emocionante, pero si activa y desactiva la tensión cientos de veces durante un segundo, el zumbador piezoeléctrico producirá un tono. Y si une unos cuantos tonos, creará música. Con este circuito y boceto se reproducirá una canción clásica. Nunca le decepcionaremos.

También hemos añadido un botón en serie con el zumbador. ¿Por qué? Porque todo generador de ruido requiere un botón de silencio. Para escuchar la canción que se va a reproducir de la placa 101 con el zumbador, debe mantener el botón pulsado. Para silenciar el zumbador, solo tiene que soltar el botón.

Elementos necesarios

Necesitará los siguientes elementos:

1 placa de pruebas
1 placa Arduino 101 o Genuino 101
1 zumbador piezoeléctrico
1 pulsador
5 cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Mini Speaker - PC Mount 12mm 2.048kHz

COM-07950

$2.10

5

Favorited Favorite 44

Momentary Pushbutton Switch - 12mm Square

COM-09190

$0.55

4

Favorited Favorite 53

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Presentación del zumbador piezoeléctrico

El zumbador es un pequeño componente con un trozo de metal que se mueve cuando se aplica tensión. Este movimiento genera un pequeño sonido o "clic". Si activa y desactiva la tensión con la suficiente rapidez, obtendrá diferentes pitidos, chirridos y zumbidos. Podrá usar la PWM para controlar la velocidad de activación y desactivación del zumbador piezoeléctrico y, a su vez, la frecuencia de audio que emite. El ajuste de la PWM le permite obtener auténticas notas del zumbador.

Si gira el zumbador y mira la parte inferior, verá un pin con un signo (+) junto a él. Este pin se conecta a una señal de un pin de PWM. El otro pin se debe conectar a tierra.

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 14; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > SIK Guide Code > Circuit_14 (Archivo > Ejemplos > Guía de códigos de SIK > Circuito_14)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 14

BUZZER

  Use the buzzer to play a song!

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
(This sketch was originally developed by D. Cuartielles for K3)
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.

*/

/*
This sketch uses the buzzer to play songs.
The Arduino's tone() command will play notes of a given frequency.
We'll provide a function that takes in note characters (a-g),
and returns the corresponding frequency from this table:

  note  frequency
  c     262 Hz
  d     294 Hz
  e     330 Hz
  f     349 Hz
  g     392 Hz
  a     440 Hz
  b     494 Hz
  C     523 Hz

For more information, see http://arduino.cc/en/Tutorial/Tone
*/

const int buzzerPin = 9;

// We'll set up an array with the notes we want to play
// change these values to make different songs!

// Length must equal the total number of notes and spaces

const int songLength = 18;

// Notes is an array of text characters corresponding to the notes
// in your song. A space represents a rest (no tone)

char notes[] = "cdfda ag cdfdg gf "; // a space represents a rest

// Beats is an array of values for each note and rest.
// A "1" represents a quarter-note, 2 a half-note, etc.
// Don't forget that the rests (spaces) need a length as well.

int beats[] = {1,1,1,1,1,1,4,4,2,1,1,1,1,1,1,4,4,2};

// The tempo is how fast to play the song.
// To make the song play faster, decrease this value.

int tempo = 150;

void setup()
{
  pinMode(buzzerPin, OUTPUT);
}

void loop()
{
  int i, duration;

  for (i = 0; i < songLength; i++) // step through the song arrays
  {
    duration = beats[i] * tempo;  // length of note/rest in ms

    if (notes[i] == ' ')          // is this a rest?
    {
      delay(duration);            // then pause for a moment
    }
    else                          // otherwise, play the note
    {
      tone(buzzerPin, frequency(notes[i]), duration);
      delay(duration);            // wait for tone to finish
    }
    delay(tempo/10);              // brief pause between notes
  }

  // We only want to play the song once, so we'll pause forever:
  while(true){}
  // If you'd like your song to play over and over,
  // remove the above statement
}

int frequency(char note)
{
  // This function takes a note character (a-g), and returns the
  // corresponding frequency in Hz for the tone() function.

  int i;
  const int numNotes = 8;  // number of notes we're storing

  // The following arrays hold the note characters and their
  // corresponding frequencies. The last "C" note is uppercase
  // to separate it from the first lowercase "c". If you want to
  // add more notes, you'll need to use unique characters.

  // For the "char" (character) type, we put single characters
  // in single quotes.

  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int frequencies[] = {262, 294, 330, 349, 392, 440, 494, 523};

  // Now we'll search through the letters in the array, and if
  // we find it, we'll return the frequency for that note.

  for (i = 0; i < numNotes; i++)  // Step through the notes
  {
    if (names[i] == note)         // Is this the one?
    {
      return(frequencies[i]);     // Yes! Return the frequency
    }
  }
  return(0);  // We looked through everything and didn't find it,
              // but we still need to return a value, so return 0.
}

Código a tener en cuenta

char notes[] = "cdfda ag cdfdg gf ";

char names[] = {'c','d','e','f','g','a','b','C'};

Hasta ahora hemos estado trabajando únicamente con datos numéricos, pero Arduino también puede trabajar con texto. Los caracteres (simples, imprimibles, letras, números y otros símbolos) tienen un tipo propio denominado "char". Cuando tiene un conjunto de caracteres, se puede definir entre comillas dobles (también denominado "cadena") O como una lista de caracteres entre comillas simples.

tone(pin, frequency, duration);

Uno de los comandos integrados muy útil de Arduino es la función tone(). Esta función controla un pin de salida a una determinada frecuencia, lo que permite controlar zumbadores y altavoces. Si le da una duración (en milisegundos), reproducirá el tono y, a continuación, se detendrá. Si no le da una duración, seguirá reproduciendo el tono sin detenerse (pero lo puede parar con otra función noTone()).

Lo que debería ver

Lo que es ver, no verá nada. Y para empezar no debería escuchar nada. Sin embargo, sí que debería poder escuchar una canción si mantiene pulsado el botón en cuanto se carga el boceto. Si escucha la canción a mitad u observa que es como si no se estuviera reproduciendo, pulse el botón de reinicio y mantenga pulsado el botón.

Si no funciona, asegúrese de que ha montado el circuito correctamente y ha verificado y cargado código en la placa o consulte la sección Solución de problemas.

Solución de problemas

No hay sonido

Debido al tamaño y forma del zumbador piezoeléctrico, es fácil confundir los orificios correctos en la placa de pruebas. Vuelva a comprobar que estén bien colocados.

Verifique también que los cables del pulsador están conectados correctamente. Si están mal conectados, el circuito nunca se completará ya tenga o no pulsado el botón.

Parece que solo reproduce una parte de la canción

Es posible que solo escuche parte de la canción para cuando pulse el botón. Para iniciar la canción otra vez, pulse el botón de reinicio maestro en la placa 101 mientras mantiene pulsado el botón de silencio.

Demasiado básico

El código está escrito para agregar fácilmente sus propias canciones. ¡Póngase en marcha y marque su propio ritmo!

Experimento 15: Usar la placa de detector de sonido

Introducción

Ha utilizado un par de entradas analógicas diferentes en los experimentos anteriores. En este experimento se utilizará el sonido como entrada y usará la placa detectora de sonido SparkFun. Se utilizará la salida Envelope de la placa para medir la intensidad en la sala y, a continuación, utilizara código denominado Switch Case para cambiar el color y el RGB en consecuencia.

A esto lo llamaremos "diversiómetro". Si las cosas se descontrolan, verá el color rojo.

Elementos necesarios

Necesitará los siguientes elementos:

1 placa de pruebas
1 placa Arduino 101 o Genuino 101
3 resistencias de 100 Ω
1 LED RGB de cátodo común
1 placa detectora de sonido SparkFun
9 cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

SparkFun Sound Detector

SEN-12642

$11.95

20

Favorited Favorite 77

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - RGB Clear Common Cathode

COM-00105

$2.25

3

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en los siguientes tutoriales:

Presentación de la placa detectora de sonido

La placa detectora de sonido es un pequeño y excelente sensor. Es un circuito con micrófono que le permite reducir la cantidad de cables. Una vez que conecte la placa a la alimentación (3,3 V) en el pin VCC y a tierra en el pin GND, hay tres opciones para diferentes señales que se pueden utilizar como entradas para la placa 101.

La primera señal, GATE, es una señal digital que se enciende cuando el sonido ambiente supera un determinado umbral. GATE también tiene un LED conectado al detector de sonido. Una vez que se enciende correctamente y hace ruido, verá el LED rojo encenderse cuando la intensidad sea alta y apagarse cuando el ruido sea bajo.

La segunda señal, ENVELOPE, escala la amplitud (el nivel de intensidad) a un valor de 10 bits de 0-1023. En una sala tranquila, este nivel se registra en aproximadamente 10.

La señal final es la señal de AUDIO sin procesar. En una habitación tranquila, la señal se nivela a aproximadamente 512 y producirá una curva de forma de onda basada en la frecuencia del sonido ambiente. La señal de AUDIO sin procesar puede servir para realizar tareas de procesamiento de sonido que no se incluyen en esta guía. Para obtener más información sobre los aspectos específicos de la placa detectora de sonido, compruebe nuestra guía de conexión para dicha placa.

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 15; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_15 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_15)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 15

SOUND DETECTOR

Use the sound detector to measure the volume of the surrounding area and change the
color of an RGB based on that volume.

 //pin variables
const int redPin = 5;
const int greenPin = 6;
const int bluePin = 9;
const int soundPin = 0;

//variables for storing raw sound and scaled value
int sound;
int scale;

void setup()
{
 //start the serial port a@ 9600bps
 Serial.begin(9600);
 //set RGB pins to OUTPUT
 pinMode(redPin, OUTPUT);
 pinMode(greenPin, OUTPUT);
 pinMode(bluePin, OUTPUT);
}

void loop()
{
 //read and store the audio from Envelope pin
 sound = analogRead(soundPin);
 //map sound which in a quiet room a clap is 300
 //from 0 to 3 to be used with switch case
 scale = map(sound, 0, 300, 0, 3);

 //print values over the serial port for debugging
 Serial.print(sound);
 Serial.print("   ");
 Serial.println(scale);

 //switch case on scaled value
switch (scale)
{
//if 0 RGB = Blue
case 0:
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, HIGH);
  break;
//if 1 RGB = Green  
case 1:
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, HIGH);
  digitalWrite(bluePin, LOW);
  break;
//if 2 RGB = Yellow  
case 2:
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, HIGH);
  digitalWrite(bluePin, LOW);
  break;
//if 3 RGB = Red
case 3:
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, LOW);
  break;
//default off
default:
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, LOW);
  break;
 }
}

Código a tener en cuenta

scale = map(sound,0,300,0,3

Esto puede parecer una extraña asignación de valores. Esta es la configuración para usar el Switch Case y tenemos que asignar un gran conjunto de valores a un máximo de tres o cuatro opciones. La función de asignación funciona de ambas formas, pero es más práctico generar rangos de valores emparejados con un Switch Case.

switch(value)
{
 case(0):
 //do something
 break;
 case(1):
 //do something else
 break;
 default:
 //do another thing
 break;
}

Switch Case resulta muy útil si cree que va a necesitar una cadena muy larga de instrucciones if else() para hacer algo basado en un rango de valores. Switch() busca una variable y, a continuación, busca una correspondencia en una lista de casos. Si la correspondencia no está disponible, se utiliza un valor predeterminado. Cada caso tiene también su propio comando break, que permite a Arduino salir del Switch Case y continuar.

Lo que debería ver

Una vez que el código se carga y comienza el boceto, el RGB se vuelve de color azul. Si el ruido es elevado, el RGB debería cambiar de azul a verde y, a continuación, a amarillo. Si hay demasiado ruido, se volverá de color rojo. No se preocupe; no vamos a llamar a la policía.

Solución de problemas

No se ilumina en amarillo ni rojo

Abra el monitor serie para realizar la depuración. Compruebe el valor de ruido bajo y, a continuación, haga mucho ruido. Ajuste la función de asignación para asegurarse de que el rango es el mismo.

Valores extraños procedentes del detector de sonido

Asegúrese de que ha conectado la placa detectora de sonido a 3,3 V y que está leyendo el pin Envelope.

Sigue sin funcionar

A veces la placa Arduino 101 se desconecta del ordenador. Intente desenchufarla y volver a enchufarla en el puerto USB.

Experimento 16: Usar un registro de desplazamientos

Introducción

Ahora vamos a entrar en el mundo de los IC (circuitos integrados) sin procesar. En este experimento, aprenderá a usar un registro de desplazamiento. El registro de desplazamiento le proporcionará a la placa 101 ocho salidas adicionales y utilizará solo tres pines de la placa. Para este experimento, usará un registro de desplazamiento para controlar ocho LED. Dos LED más que en el experimento 4.

Elementos necesarios

Necesitará los siguientes elementos:

1 placa de pruebas
1 placa Arduino 101 o Genuino 101
8 LED
8 resistencias de 330 Ω
1 registro de desplazamiento de 8 bits 74HC595
19 cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - Basic Red 5mm

COM-09590

$0.45

Shift Register 8-Bit - SN74HC595

COM-13699

$1.05

Favorited Favorite 28

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en los siguientes tutoriales:

Presentación del registro de desplazamiento

El registro de desplazamiento es un circuito integrado (IC). Los IC son diminutos conjuntos cerrados de plástico que albergan los circuitos más populares y que se usan con más frecuencia. Los IC actúan como componentes individuales que realizan un trabajo específico y simplifican lo que solía ser un diseño de circuito que requería mucho espacio y tiempo.

El registro de desplazamiento básicamente le permite controlar hasta ocho salidas mientras solo usa tres pines en la placa 101. Permite controlar más salidas con menos pines en comparación con el experimento 4, donde usó seis pines para seis salidas individuales.

Piénselo de esta manera: los datos que entran en el registro de desplazamiento serían como un tren de ocho vagones diferentes. Si un vagón está repleto de carga, los datos representan un 1. Si el vagón está vacío, los datos representan un 0. Cuando todo el tren entra en el registro de desplazamiento, se separa y cada vagón se dirige hacia su propia vía. Estas vías se pueden traducir en los ochos pines de entrada del registro de desplazamiento. Si el vagón está lleno (1), el pin que está activado tendrá el valor ALTO; si el vagón está vacío (0), el pin tendrá el valor BAJO. Si envía de manera constante un tren detrás de otro al registro de desplazamiento, puede encender los LED o controlar algo como una pantalla de 7 segmentos para contar hacia atrás o incluso una gran cantidad de motores que se encienden en momentos diferentes. Todo esto sucede simplemente enviando trenes al registro de desplazamiento con diferentes patrones de 1 y 0.

Para obtener más información acerca de ~~trenes~~ registros de desplazamiento, eche un vistazo a nuestro tutorial de registros de desplazamiento.

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 16; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_16 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_16)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 16

SHIFT REGISTER

  Use a shift register to turn three pins into eight (or more!)
  outputs

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

// Pin definitions:
// The 74HC595 uses a type of serial connection called SPI
// (Serial Peripheral Interface) that requires three pins:

int datapin = 2;
int clockpin = 3;
int latchpin = 4;

// We'll also declare a global variable for the data we're
// sending to the shift register:

byte data = 0;

void setup()
{
  // Set the three SPI pins to be outputs:

  pinMode(datapin, OUTPUT);
  pinMode(clockpin, OUTPUT);  
  pinMode(latchpin, OUTPUT);
}

void loop()
{
  // We're going to use the same functions we played with back
  // in circuit 04, "Multiple LEDs," we've just replaced
  // digitalWrite() with a new function called shiftWrite()
  // (see below). We also have a new function that demonstrates
  // binary counting.

  // To try the different functions below, uncomment the one
  // you want to run, and comment out the remaining ones to
  // disable them from running.

  oneAfterAnother();      // All on, all off

  //oneOnAtATime();       // Scroll down the line

  //pingPong();           // Like above, but back and forth

  //randomLED();          // Blink random LEDs

  //marquee();

  //binaryCount();        // Bit patterns from 0 to 255
}

void shiftWrite(int desiredPin, boolean desiredState)

// This function lets you make the shift register outputs
// HIGH or LOW in exactly the same way that you use digitalWrite().

// Like digitalWrite(), this function takes two parameters:

//    "desiredPin" is the shift register output pin
//    you want to affect (0-7)

//    "desiredState" is whether you want that output
//    to be HIGH or LOW

// Inside the Arduino, numbers are stored as arrays of "bits,"
// each of which is a single 1 or 0 value. Because a "byte" type
// is also eight bits, we'll use a byte (which we named "data"
// at the top of this sketch) to send data to the shift register.
// If a bit in the byte is "1," the output will be HIGH. If the bit
// is "0," the output will be LOW.

// To turn the individual bits in "data" on and off, we'll use
// a new Arduino commands called bitWrite(), which can make
// individual bits in a number 1 or 0.
{
  // First we'll alter the global variable "data," changing the
  // desired bit to 1 or 0:

  bitWrite(data,desiredPin,desiredState);

  // Now we'll actually send that data to the shift register.
  // The shiftOut() function does all the hard work of
  // manipulating the data and clock pins to move the data
  // into the shift register:

  shiftOut(datapin, clockpin, MSBFIRST, data);

  // Once the data is in the shift register, we still need to
  // make it appear at the outputs. We'll toggle the state of
  // the latchPin, which will signal the shift register to "latch"
  // the data to the outputs. (Latch activates on the high-to
  // -low transition).

  digitalWrite(latchpin, HIGH);
  digitalWrite(latchpin, LOW);
}

/*
oneAfterAnother()

This function will light one LED, delay for delayTime, then light
the next LED, and repeat until all the LEDs are on. It will then
turn them off in the reverse order.
*/

void oneAfterAnother()
{
  int index;
  int delayTime = 100; // Time (milliseconds) to pause between LEDs
                       // Make this smaller for faster switching

  // Turn all the LEDs on:

  // This for() loop will step index from 0 to 7
  // (putting "++" after a variable means add one to it)
  // and will then use digitalWrite() to turn that LED on.

  for(index = 0; index <= 7; index++)
  {
    shiftWrite(index, HIGH);
    delay(delayTime);                
  }

  // Turn all the LEDs off:

  // This for() loop will step index from 7 to 0
  // (putting "--" after a variable means subtract one from it)
  // and will then use digitalWrite() to turn that LED off.

  for(index = 7; index >= 0; index--)
  {
    shiftWrite(index, LOW);
    delay(delayTime);
  }
}

/*
oneOnAtATime()

This function will step through the LEDs, lighting one at at time.
*/

void oneOnAtATime()
{
  int index;
  int delayTime = 100; // Time (milliseconds) to pause between LEDs
                       // Make this smaller for faster switching

  // step through the LEDs, from 0 to 7

  for(index = 0; index <= 7; index++)
  {
    shiftWrite(index, HIGH);    // turn LED on
    delay(delayTime);       // pause to slow down the sequence
    shiftWrite(index, LOW); // turn LED off
  }
}

/*
pingPong()

This function will step through the LEDs, lighting one at at time,
in both directions.
*/

void pingPong()
{
  int index;
  int delayTime = 100; // time (milliseconds) to pause between LEDs
                       // make this smaller for faster switching

  // step through the LEDs, from 0 to 7

  for(index = 0; index <= 7; index++)
  {
    shiftWrite(index, HIGH);    // turn LED on
    delay(delayTime);       // pause to slow down the sequence
    shiftWrite(index, LOW); // turn LED off
  }

  // step through the LEDs, from 7 to 0

  for(index = 7; index >= 0; index--)
  {
    shiftWrite(index, HIGH);    // turn LED on
    delay(delayTime);       // pause to slow down the sequence
    shiftWrite(index, LOW); // turn LED off
  }
}

/*
randomLED()

This function will turn on random LEDs. Can you modify it so it
also lights them for random times?
*/

void randomLED()
{
  int index;
  int delayTime = 100; // time (milliseconds) to pause between LEDs
                       // make this smaller for faster switching

  // The random() function will return a semi-random number each
  // time it is called. See http://arduino.cc/en/Reference/Random
  // for tips on how to make random() more random.

  index = random(8);    // pick a random number between 0 and 7

  shiftWrite(index, HIGH);  // turn LED on
  delay(delayTime);     // pause to slow down the sequence
  shiftWrite(index, LOW);   // turn LED off
}

/*
marquee()

This function will mimic "chase lights" like those around signs.
*/

void marquee()
{
  int index;
  int delayTime = 200; // Time (milliseconds) to pause between LEDs
                       // Make this smaller for faster switching

  // Step through the first four LEDs
  // (We'll light up one in the lower 4 and one in the upper 4)

  for(index = 0; index <= 3; index++)
  {
    shiftWrite(index, HIGH);    // Turn a LED on
    shiftWrite(index+4, HIGH);  // Skip four, and turn that LED on
    delay(delayTime);       // Pause to slow down the sequence
    shiftWrite(index, LOW); // Turn both LEDs off
    shiftWrite(index+4, LOW);
  }
}

/*
binaryCount()

Numbers are stored internally in the Arduino as arrays of "bits,"
each of which is a 1 or 0\. Just like the base-10 numbers we use
every day, The position of the bit affects the magnitude of its
contribution to the total number:

Bit position   Contribution
0              1
1              2
2              4
3              8
4              16
5              32
6              64
7              128

To build any number from 0 to 255 from the above 8 bits, just
select the contributions you need to make. The bits will then be
1 if you use that contribution, and 0 if you don't.

This function will increment the "data" variable from 0 to 255
and repeat. When we send this value to the shift register and LEDs,
you can see the on-off pattern of the eight bits that make up the
byte. See http://www.arduino.cc/playground/Code/BitMath for more
information on binary numbers.
*/

void binaryCount()
{
  int delayTime = 1000; // time (milliseconds) to pause between LEDs
                        // make this smaller for faster switching

  // Send the data byte to the shift register:

  shiftOut(datapin, clockpin, MSBFIRST, data);

  // Toggle the latch pin to make the data appear at the outputs:

  digitalWrite(latchpin, HIGH);
  digitalWrite(latchpin, LOW);

  // Add one to data, and repeat!
  // (Because a byte type can only store numbers from 0 to 255,
  // if we add more than that, it will "roll around" back to 0
  // and start over).

  data++;

  // Delay so you can see what's going on:

  delay(delayTime);
}

Código a tener en cuenta

shiftOut(datapin, clockpin, MSBFIRST, data);

Podrá comunicarse con el registro de desplazamiento (y muchos otros elementos) con la SPI. Esta interfaz utiliza una línea de datos y una línea de reloj independiente que funcionan conjuntamente para enviar y recibir datos en la placa 101 a alta velocidad. El parámetro MSBFIRST especifica el orden en el que se envían los bits individuales; en este caso, primero enviaremos el bit más significativo.

bitWrite(data, desiredPin, desiredState);

Los bits son los fragmentos más pequeños de memoria en un ordenador; cada uno puede almacenar un valor: "1" o "0". Los números más grandes se almacenan como matrices de bits. A veces queremos manipular estos bits directamente; por ejemplo, ahora vamos a enviar ocho bits al registro de desplazamiento y queremos convertirlos en 1 o 0 para activar o desactivar los LED. Arduino tiene varios comandos, como bitWrite(), que nos permite hacer esto de manera fácil.

Lo que debería ver

Debería ver que los LED se encienden de manera similar al experimento 4 (pero esta vez, está utilizando un registro de desplazamiento). Si no es así, asegúrese de que ha montado el circuito correctamente y ha verificado y cargado código en la placa. Consulte la sección Solución de problemas.

Solución de problemas

El LED de alimentación de Arduino se apaga

Esto nos ha pasado varias veces. Esto ocurre cuando el chip se inserta al revés. Si lo soluciona rápido, nada se romperá.

No funciona bien

Sentimos parecer un disco rayado, pero probablemente es algo tan sencillo como un cable mal conectado.

Frustración

xperimento 17: Usar una pantalla LCD

Introducción

En este experimento, aprenderá a usar una LCD. Una LCD (pantalla de cristal líquido) es una pantalla simple que puede mostrar comandos, segmentos de información o las lecturas del sensor; todo depende de lo que programe en la placa. En este circuito, aprenderá los aspectos básicos de la incorporación de una pantalla LCD en su proyecto.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x potenciómetro
1x pantalla LCD de 3,3 V
16x cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Trimpot 10K Ohm with Knob

COM-09806

$1.05

6

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Basic 16x2 Character LCD - White on Black 3.3V

LCD-09052

3 Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Presentación de la pantalla LCD

El SIK 101 incluye una pantalla de cristal líquido (LCD). Esta pantalla es similar a la que puede encontrar en el microondas o en el panel de su coche, o si es lo bastante mayor para recordarlo, el juguete Speak and Spell. Las pantallas LCD son una gran manera de visualizar datos o información de la placa 101 sin tener que conectarla a su portátil.

Esta pantalla LCD cuenta con espacios para un total de 32 caracteres organizados en una rejilla que contiene dos filas de 16 caracteres. La pantalla LCD se controla a través de una biblioteca que facilita su uso con la placa 101. El cableado puede parecer un poco abrumador, pero es un desafío que vale la pena.

**Consejo experto: cuando conecte los cables de la pantalla LCD, empiece por un lado de los pines de la pantalla LCD y vaya hacia el centro. Cuando llegue a un pin que no se va a usar, vaya al otro lado y repita el proceso. Este método ayudará a evitar que no se olvide accidentalmente de un pin o que coloque mal los cables. **

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 17; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_17 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_17)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y vea qué es lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 17

LIQUID CRYSTAL DISPLAY (LCD)

  This sketch will show you how to connect an LCD to your Arduino
  and display any data you wish.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit https://www.sparkfun.com/products/12060 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

// Load the LiquidCrystal library, which will give us
// commands to interface to the LCD:

#include 

// Initialize the library with the pins we're using.
// (Note that you can use different pins if needed.)
// See http://arduino.cc/en/Reference/LiquidCrystal
// for more information:

LiquidCrystal lcd(12,11,5,4,3,2);

void setup()
{
  // The LiquidCrystal library can be used with many different
  // LCD sizes. We're using one that's 2 lines of 16 characters,
  // so we'll inform the library of that:

  lcd.begin(16, 2);

  // Data sent to the display will stay there until it's
  // overwritten or power is removed. This can be a problem
  // when you upload a new sketch to the Arduino but old data
  // remains on the display. Let's clear the LCD using the
  // clear() command from the LiquidCrystal library:

  lcd.clear();

  // Now we'll display a message on the LCD!

  // Just as with the Arduino IDE, there's a cursor that
  // determines where the data you type will appear. By default,
  // this cursor is invisible, though you can make it visible
  // with other library commands if you wish.

  // When the display powers up, the invisible cursor starts
  // on the top row and first column.

  lcd.print("hello, world!");

  // Adjusting the contrast (IMPORTANT!)

  // When you run the sketch for the first time, there's a
  // very good chance you won't see anything on the LCD display.
  // This is because the contrast likely won't be set correctly.
  // Don't worry, it's easy to set, and once you set it you won't
  // need to change it again.

  // Run the sketch, then turn the potentiometer until you can
  // clearly see the "hello, world!" text. If you still can't
  // see anything, check all of your connections, and ensure that
  // the sketch was successfully uploaded to the Arduino.
}

void loop()
{
  // You can move the invisible cursor to any location on the
  // LCD before sending data. Counting starts from 0, so the top
  // line is line 0 and the bottom line is line 1\. Columns range
  // from 0 on the left side, to 15 on the right.

  // In additon to the "hello, world!" printed above, let's
  // display a running count of the seconds since the Arduino
  // was last reset. Note that the data you send to the display
  // will stay there unless you erase it by overwriting it or
  // sending an lcd.clear() command.

  // Here we'll set the invisible cursor to the first column
  // (column 0) of the second line (line 1):

  lcd.setCursor(0,1);

  // Now we'll print the number of seconds (millis() / 1000)
  // since the Arduino last reset:

  lcd.print(millis()/1000);

  // TIP: Since the numeric data we're sending is always growing
  // in length, new values will always overwrite the previous ones.
  // However, if you want to display varying or decreasing numbers
  // like a countdown, you'll find that the display will leave
  // "orphan" characters when the new value is shorter than the
  // old one.

  // To prevent this, you'll need to erase the old number before
  // writing the new one. You can do this by overwriting the
  // last number with spaces. If you erase the old number and
  // immediately write the new one, the momentary erase won't
  // be noticeable. Here's a typical sequence of code:

  // lcd.setCursor(0,1);   // Set the cursor to the position
  // lcd.print("       "); // Erase the largest possible number
  // lcd.setCursor(0,1);   // Reset the cursor to the original position
  // lcd.print(millis()/1000); // Print our value

  // NEXT STEPS:

  // Now you know the basics of hooking up an LCD to the Arduino,
  // and sending text and numeric data to the display!

  // The LCD library has many commands for turning the
  // cursor on and off, scrolling the screen, etc. See:
  // http://arduino.cc/en/Reference/LiquidCrystal
  // for more information.

  // Arduino also comes with a number of built-in examples
  // showing off the features of the LiquidCrystal library.
  // These are locted in the file/examples/LiquidCrystal menu.

  // Have fun, and let us know what you create!
  // Your friends at SparkFun.
}

Código a tener en cuenta

#include<liquidcrystal.h></liquidcrystal.h>

Este segmento de código indica al IDE de Arduino que incluya la biblioteca de una pantalla LCD simple. Sin él, ninguno de los comandos funcionará, así que asegúrese de incluirlo.

lcd.print(“hello, world!”);

Esta es la primera vez que verá algo en la pantalla. Puede que sea necesario ajustar el contraste para que se vea correctamente. Gire el potenciómetro hasta que pueda ver claramente el texto.

lcd.clear();

Sí, lo ha adivinado. Este método se utiliza para aclarar los datos que se muestran en la pantalla LCD.

lcd.setCursor(0,1);

Si mira de cerca, observará que cada carácter tiene un pequeño cuadro alrededor y que estos cuadros están en una rejilla de 2x16. El primer número de este método se refiere a la columna (empiece a contar desde 0, somos conscientes de que hay que acostumbrarse) y el segundo número hace referencia a la fila. Por lo tanto, el valor 0,1 hace referencia a la primera columna y a la segunda fila.

Lo que debería ver

Inicialmente, debería ver las palabras "hello, world!" en la pantalla LCD. Recuerde que puede ajustar el contraste mediante el potenciómetro si no puede ver claramente las palabras. Si tiene problemas, asegúrese de que el código es correcto y vuelva a comprobar las conexiones. Consulte también la sección Solución de problemas a continuación.

Solución de problemas

La pantalla está en blanco o completamente iluminada

Juegue con el contraste girando el potenciómetro. Si se ajusta incorrectamente, no podrá leer el texto.

No funciona

Vuelva a comprobar el código, especialmente el que ha incluido en la biblioteca de LCD.

La pantalla parpadea

Vuelva a comprobar las conexiones en la placa de pruebas y la placa 101.

Experimento 18: Leer el acelerómetro integrado

Introducción

En el experimento 13 ha probado diferentes entradas para controlar la velocidad y la dirección de un motor. En este experimento hará algo similar, pero utilizará el acelerómetro integrado en la placa Arduino 101 como entrada.

El acelerómetro mide las fuerzas gravitatorias que se aplican al sensor en diferentes direcciones. Puede extrapolar mucha información de los datos del acelerómetro si se está moviendo. Pero también es útil para saber qué lado está inclinado cuando está parado. La gravedad de la Tierra es una fuerza omnipresente que se puede medir con el acelerómetro. La usaremos de esta manera para determinar la orientación de la placa Arduino 101 y a partir de ahí podrá hacer que el motor se mueva hacia delante, atrás o que esté parado. ¡Empecemos!

Elementos necesarios

Necesitará los siguientes elementos:

1 placa de pruebas
1 placa Arduino 101 o Genuino 101
1 controlador del motor SparkFun
1 motor reductor 42:1 para aficionados
13 cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Hobby Gearmotor - 140 RPM (Pair)

ROB-13302

$5.50

6

SparkFun Motor Driver - Dual TB6612FNG (1A)

ROB-09457

18 Retired

Favorited Favorite 18

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en los siguientes tutoriales:

Presentación del acelerómetro.

Los acelerómetros son dispositivos que miden la aceleración, es decir, es la tasa de variación de la velocidad de un objeto. Se mide en metros por segundo al cuadrado (m/s2) o en fuerzas G (G). Una sola fuerza G aquí en el planeta Tierra es equivalente a 9,8 m/s2, pero esto varía ligeramente con la altitud (y será un valor diferente en diferentes planetas debido a las variaciones en la fuerza de gravedad). Los acelerómetros son útiles para detectar vibraciones en sistemas o para aplicaciones de orientación.

Conexión del hardware

¿Está preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene dificultades para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 18; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_18 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_18)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 18

Controlling a Motor Using an Accelerometer

  Use the on-board accelerometer of the 101 board as an input to control
  a motor based on its orientation in space. If you tilt the 101 to the left,
  the motor spins in one direction; tilted to the right, it spins the opposite direction; and if it
  is flat, the motor stops.

This sketch was written by SparkFun Electronics, and based on the Orientation example
in the CurieIMU Library Examples
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

#include "CurieIMU.h"

const int DIR_A = 4;
const int DIR_B = 5;
const int PWM = 6;

// previous orientation (for comparison). Start at (-1) to start with

void setup()
{
 //set motor control pins to OUTPUT
pinMode(DIR_A, OUTPUT);
pinMode(DIR_B, OUTPUT);
pinMode(PWM, OUTPUT);

 // Start the acceleromter
 CurieIMU.begin();

// Set the accelerometer range to 2G
CurieIMU.setAccelerometerRange(2);
}

void loop()
{
 // read accelerometer:
 int x = CurieIMU.readAccelerometer(X_AXIS);
 int y = CurieIMU.readAccelerometer(Y_AXIS);
 int z = CurieIMU.readAccelerometer(Z_AXIS);

 // calculate the absolute values, to determine the largest
 int absX = abs(x);
 int absY = abs(y);
 int absZ = abs(z);

if ( (absZ > absX) && (absZ > absY))
{
 // base orientation on Z
 if (z > 0)
 {
  brake();
 }
}

 //else if Y is greater than X and Z its on edge
 else if ( (absY > absX) && (absY > absZ))
 {
  // if Y is positive orientation (digital pins up)and is set to 1
  if (y > 0)
  {
    forward();
  }
  //the Y is in the negative orientation (analog pins up) and is set to 2
  else
  {
    reverse();
  }
}
}
//custom function for driving the motor forward
void forward()
{
  digitalWrite(DIR_A, HIGH);
  digitalWrite(DIR_B, LOW);
  digitalWrite(PWM, HIGH);
}

//custom function for driving the motor in reverse
void reverse()
{
  digitalWrite(DIR_A, LOW);
  digitalWrite(DIR_B, HIGH);
  digitalWrite(PWM, HIGH);
}

//custom function for braking the motor
void brake()
{
  digitalWrite(DIR_A, LOW);
  digitalWrite(DIR_B, LOW);
  digitalWrite(PWM, LOW);
}

Código a tener en cuenta

#include "CurieIMU.h"

El puerto serie de Arduino se puede utilizar tanto para recibir como para enviar datos. Ya que pueden recibirse datos en cualquier momento, la placa Arduino 101 guarda o almacena en el búfer los datos que entran en el puerto hasta que esté listo para utilizarlos. El comando Serial.available() devuelve el número de caracteres que el puerto ha recibido, pero que no se han usado en el boceto todavía. Cero significa que no se han recibido datos.

int x = CurieIMU.readAccelerometer(X_AXIS);

Leemos el valor del acelerómetro transfiriendo la constante de X_AXIS al método readAccelerometer de IMU Curie. Esto devolverá la lectura en tiempo real del sensor. Para leer otro eje puede transferir las constantes de X_AXIS, Y_AXIS y Z_AXIS.

int absX = abs(x);

En este experimento no estamos necesariamente interesados en los valores positivos o negativos. Solo queremos saber cuáles son los más altos para poder tomar una decisión a partir de ahí. Hemos usado la función abs() que obtiene el valor absoluto de un número (básicamente elimina el signo (-)). Lo almacenamos en una variable local denominada absX, de modo que si alguna vez queremos acceder al valor x sin procesar, podamos hacerlo.

language:cpp
//if Z axis is greater than X and Y its facing upright
if ( (absZ > absX) && (absZ > absY))
{
 // base orientation on Z
 if (z > 0)
 {
  brake();
 }
}

 //else if Y is greater than X and Z its on edge
 else if ( (absY > absX) && (absY > absZ))
 {
  // if Y is positive orientation (digital pins up)and is set to 1
  if (y > 0)
  {
    forward();
  }
  //the Y is in the negative orientation (analog pins up) and is set to 2
  else
  {
    reverse();
  }
}

Una vez que tenemos las lecturas del acelerómetro en valor absoluto, podemos compararlas utilizando una instrucción if(). En este ejemplo solo queremos comparar los valores que están relacionados con la inclinación de la placa hacia la izquierda y la derecha, pero aun así necesitamos los tres ejes para averiguarlo. Por ejemplo, si Y es superior a X, el eje Y está orientado hacia abajo (apuntado en la dirección de la gravedad). A continuación, podemos hacer una comparación final para ver si es superior a 0 a fin de garantizar que está en sentido positivo. Hemos establecido la dirección del motor en función de esas comparaciones.

Lo que debería ver

Una vez que el código se carga en la placa 101, sostenga la placa 101 e inclínela hacia la izquierda (pines de entrada analógica hacia abajo). El motor debería empezar a moverse en una dirección. Ahora inclínela hacia la dirección contraria (pines GPIO digitales hacia abajo); el motor debería moverse en dirección contraria. Cuando pone la placa en horizontal, el motor debe pararse. Si no es así, consulte la sección Solución de problemas a continuación.

Solución de problemas

El motor no gira

Asegúrese de que el cableado del controlador del motor es correcto. Son muchos cables.

Todavía sigue sin funcionar

Vuelva a comprobar que el código se ha cargado en la placa 101. A veces lleva tiempo cargarlo a la placa 101, así que tenga paciencia.

Sigue sin funcionar

A veces la placa Arduino se desconecta del ordenador. Intente desenchufarla y volver a enchufarla en el puerto USB.

Experimento 19: Detección de pulsación

Introducción

Uno de los puntos fuertes de la placa 101 es que cuenta con tecnología muy avanzada para el reconocimiento de movimientos y gestos. Todo esto es posible a través de la unidad de medición de inercia (IMU) en la placa 101. La IMU mide los datos del acelerómetro (fuerza gravitatoria) y del giroscopio (rotación). Hemos estado probando el acelerómetro en el experimento 18. Vamos a profundizar un poco más y a aprovechar el módulo de Curie, que puede interpretar los datos para determinar si está dando un paso y contarlos, detectar si está pulsando la placa e incluso su orientación en el espacio.

Como ejemplo del uso de la combinación de la IMU y el módulo de Curie, crearemos un simple circuito RGB que parpadeará en verde dos veces si pulsa dos veces la parte superior de la placa 101 y parpadeará en rojo dos veces si pulsa dos veces la parte inferior de la placa 101.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x LED RGB de cátodo común
3x resistencia de 100 Ω
6x cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Mini Speaker - PC Mount 12mm 2.048kHz

COM-07950

$2.10

5

Favorited Favorite 44

Momentary Pushbutton Switch - 12mm Square

COM-09190

$0.55

4

Favorited Favorite 53

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos descritos en los siguientes tutoriales:

Presentación de la unidad de medición inercial

Una unidad de medición inercial (IMU) es una combinación de sensores que se utiliza para determinar la orientación de los sensores en el espacio tridimensional. La placa 101 utiliza un acelerómetro y un giroscopio para detectar la orientación física (para ello, mide la gravedad sobre el sensor) y un giroscopio para detectar el movimiento de rotación.

La placa 101 puede traducir los datos de la IMU en determinados gestos preprogramados como: dar un paso, pulsar una o dos veces la placa, o lanzar la placa. Este experimento se centrará en la detección de pulsaciones/dobles pulsaciones, pero le animamos a probar también el otro código de ejemplo que se encuentra en File > Examples > CurieIMU (Archivo > Ejemplos > IMU Curie).

Nota: La placa 101 tiene una IMU y se accede a través de la biblioteca de Arduino. Para usar la IMU no es necesario utilizar cables.

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene problemas para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 19; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > SIK Guide Code > Circuit_19 (Archivo > Ejemplos > Guía de códigos de SIK > Circuito_19)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 19

TAP DETECTION

Use the 101 board's on-board IMU to detect a tap and double tap and react accordingly.

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

#include "CurieIMU.h"

void setup()
{

 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);

 // Initialise the IMU
 CurieIMU.begin();
 CurieIMU.attachInterrupt(eventCallback);

 // Increase Accelerometer range to allow detection of stronger taps (< 4g)
 CurieIMU.setAccelerometerRange(3);

 // Reduce threshold to allow detection of weaker taps (>= 750mg)
 CurieIMU.setDetectionThreshold(CURIE_IMU_TAP, 750); // (750mg)

 // Set the time window for 2 taps as a double tap (<= 250 milliseconds)
 CurieIMU.setDetectionDuration(CURIE_IMU_DOUBLE_TAP, 250);

 // Enable Double-Tap detection
 CurieIMU.interrupts(CURIE_IMU_DOUBLE_TAP);
 }

void loop()
{
 // nothing happens in the loop because all the action happens
 // in the callback function.  
 }

static void eventCallback()
{
 if (CurieIMU.getInterruptStatus(CURIE_IMU_DOUBLE_TAP)) {
    if (CurieIMU.tapDetected(Z_AXIS, NEGATIVE))
    {
    digitalWrite(5, HIGH);
    digitalWrite(6, LOW);
    delay(250);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    delay(250);
    digitalWrite(5, HIGH);
    digitalWrite(6, LOW);
    delay(250);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    delay(250);
    }
   else if (CurieIMU.tapDetected(Z_AXIS, POSITIVE))
   {
    digitalWrite(5, LOW);
    digitalWrite(6, HIGH);
    delay(250);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    delay(250);
    digitalWrite(5, LOW);
    digitalWrite(6, HIGH);
    delay(250);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    delay(250);
   }
  else
  {
  digitalWrite(5, LOW);
  digitalWrite(6, LOW);
  }
 }
}

Código a tener en cuenta

CurieIMU.begin();

Inicialice o comience a usar la IMU incorporada en la placa. Sin esto, la placa 101 no podría registrar datos de IMU.

CurieIMU.attachInterrupt(eventCallback);

Las interrupciones son eventos que interrumpen el bucle e indican a la placa 101 que haga algo inmediatamente. A continuación, la placa 101 sale del bucle, realiza lo indicado y vuelve al bucle. La interrupción especifica una función que se va a realizar cuando se activa la interrupción. En este caso: eventCallback.

 // Reduce threshold to allow detection of weaker taps (>= 750mg)
 CurieIMU.setDetectionThreshold(CURIE_IMU_TAP, 750); // (750mg)

 // Set the time window for 2 taps as a double tap (<= 250 milliseconds)
 CurieIMU.setDetectionDuration(CURIE_IMU_DOUBLE_TAP, 250);

Para utilizar la IMU a fin de detectar una doble pulsación, se requiere una determinada configuración. Es necesario establecer un umbral de fuerza para una pulsación más dura y para una pulsación más suave. También es necesario especificar una duración para una pulsación doble para que el módulo Curie pueda saber cuál es la diferencia entre una sola pulsación y una pulsación doble.

CurieIMU.interrupts(CURIE_IMU_DOUBLE_TAP); Por último, adjuntamos la interrupción al evento de pulsación doble. Por lo tanto, siempre que se realice una doble pulsación, la placa 101 ejecutará la función eventCallback.

Lo que debería ver

Una vez que el código se carga, el RGB se debe apagar. Sujete la placa y pulse dos veces la parte superior con el dedo con un ritmo y una sincronización que sean similares al doble clic con un ratón. El RGB debe parpadear en color verde dos veces y, a continuación, apagarse de nuevo. Si hace lo mismo con la parte inferior de la placa, parpadeará en color rojo.

Solución de problemas

La biblioteca no se compila

Vuelva a comprobar que dispone de una instrucción #include "CurieIMU.h". Si es el caso, asegúrese de que el nombre del archivo de encabezado está entre comillas y no entre comillas angulares.

No ocurre nada al pulsar dos veces

La placa 101 espera un rango de sincronización especificado para la doble pulsación. Intente acelerar las pulsaciones o ajuste la sincronización de la doble pulsación en el método CurieIMU.setDetectionDuration(CURIE_IMU_DOUBLE_TAP, 250);.

Sigue sin funcionar

Puede ajustar la sensibilidad del acelerómetro. En el ejemplo se establece en 2 G o el doble de la cantidad de gravedad que solemos experimentar en la Tierra. Si lo disminuye, la sensibilidad aumentará.

Experimento 20: Usar el reloj de tiempo real integrado (RTC)

Introducción

Los microcontroladores son fantásticos a la hora de controlar el tiempo con su propio ritmo. Con esto nos referimos a su tiempo operativo. Funcionan con una señal de reloj interno que le permite llevar un registro de los milisegundos y microsegundos desde que se encienden. Pero los microcontroladores no tienen manera de saber el tiempo real, es decir, el tiempo en el que basamos nuestros días y horarios.

En este experimento, configurará el reloj y, a continuación, se mostrará la fecha y hora en la pantalla LCD que ha aprendido a usar en el Experimento 17.

Nota: La placa 101 no tiene una batería de reserva para el reloj de tiempo real (RTC), de modo que si desconecta la placa o las baterías se agotan, tendrá que restablecer el RTC en el código o desarrollar un circuito que le permita ajustar la hora.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x potenciómetro
1x pantalla LCD de 3,3 V
16x cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Trimpot 10K Ohm with Knob

COM-09806

$1.05

6

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

Basic 16x2 Character LCD - White on Black 3.3V

LCD-09052

3 Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired

Lectura sugerida

Antes de continuar con este experimento, le recomendamos que se familiarice con los conceptos en el siguiente tutorial:

Guía de conexión de OLED

Presentación del reloj de tiempo real (RTC)

Un microcontrolador funciona muy bien a la hora de controlar el tiempo operativo, el tiempo necesario para realizar su trabajo. Los microcontroladores suelen llevar un registro de los milisegundos desde que se encienden. Sin embargo, hacen un trabajo terrible a la hora de llevar el registro del tiempo que nosotros usamos (tiempo real). Los microcontroladores utilizan un reloj de tiempo real (RTC) para controlar el tiempo que transcurre desde un punto de partida concreto.

El RTC controla las horas, los minutos y los segundos de un reloj, así como el día, el mes y el año del calendario. En la placa 101, se debe configurar la fecha y la hora la primera vez que se enciende. Desde ese momento, debería mantener la hora exacta. A continuación, puede usar la hora para que se produzcan eventos en una fecha u hora concretas, o incluso como marca de tiempo para el registro de datos.

Nota: Si la placa 101 pierde alimentación, tendrá que restablecer el reloj en el código. Además, el RTC es un componente integrado en la placa 101 y no requiere ningún cable.

Conexión del hardware

¿Preparado para comenzar a conectar todo? Consulte el diagrama de cableado siguiente para ver cómo está conectado todo.

Componentes polarizados

Preste especial atención a las marcas de los componentes que indican cómo colocarlo en la placa de pruebas. Los componentes polarizados solo se pueden conectar a un circuito en una sola dirección.

Diagrama de cableado del experimento

¿Tiene problemas para ver el circuito? Haga clic en el diagrama de cableado para verlo más de cerca.

Abrir el boceto

Abra el software IDE de Arduino en su ordenador. La codificación en el lenguaje de Arduino controlará el circuito. Abra el código del circuito 20; para ello, acceda a "101 SIK Guide Code" (Guía de códigos de SIK 101) que ha descargado y guardado en la carpeta "Examples" (Ejemplos) anteriormente.

Para abrir el código vaya a: File > Examples > 101 SIK Guide Code > Circuit_20 (Archivo > Ejemplos > Guía de códigos de SIK 101 > Circuito_20)

También puede copiar y pegar el siguiente código en el IDE de Arduino. Cárguelo y observe lo que ocurre.

language:cpp
/*
SparkFun Inventor's Kit
Example sketch 20

DISPLAYING THE DATE AND TIME

This sketch reads the RTC data and prints it on the LCD screen

This sketch was written by SparkFun Electronics,
with lots of help from the Arduino community.
This code is completely free for any use.
Visit http://learn.sparkfun.com/products/2 for SIK information.
Visit http://www.arduino.cc to learn more about Arduino.
*/

//include the CurieTime Library
#include 
#include 

//instantiate the lcd
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
  //start lcd at 16 x 2
  lcd.begin(16, 2);

  //clear the lcd
  lcd.clear();

  //set time to 1:35:24 on April 4th, 2016\. Please change to your time / date
  setTime(1, 35, 24, 4, 10, 2016);
}

void loop()
{
 //create a character array of 16 characters for the time
 char clockTime[16];
 //use sprintf to create a time string of the hour, minte and seconds
 sprintf(clockTime, "    %2d:%2d:%2d    ", hour(), minute(), second());

 //create a character array of 15 characters for the date
 char dateTime[16];
 //use sprintf to create a date string from month, day and year
 sprintf(dateTime, "   %2d/%2d/%4d   ", month(), day(), year());

 //set cursor to column 0, row 0
 lcd.setCursor(0, 0);
 //print the date string over lcd
 lcd.print(dateTime);
 //set cursor to column 0, row 1
 lcd.setCursor(0, 1);
 //print the time string over lcd
 lcd.print(clockTime);
}

Código a tener en cuenta

setTime(1,35,00,4,10,2016);

Se debe configurar el RTC en la placa 101 cuando se encienda. Esto se hace mediante la función setTime(). Tendrá que editar en orden los 6 parámetros de setTime(): horas, minutos, segundos, mes, día y año. Si la placa 101 pierde alimentación por algún motivo, tendrá que restablecerla utilizando esta función.

sprintf(dateTime, " %2d/%2d/%4d ", month(), day(), year()); sprintf() es una función que sirve para compilar cadenas. Es una manera sencilla de elaborar cadenas; para ello, se recopilan datos y se colocan en un conjunto de caracteres, es decir, una cadena en Arduino. Los datos se insertan en %2d y %4d con el número de dígitos especificados, es decir, %4d serían 4 dígitos. Por último, transfiere los datos que desea insertar en las cadenas como parámetros. En este caso, month(), day() y year().

Lo que debería ver

Una vez que el código esté completamente cargado, debería ver dos líneas de texto que se muestran en la pantalla LCD. La primera línea debería ser la fecha (que solo debe cambiar una vez al día) y la segunda línea la hora actual, que debe ir aumentando. Si no es así, consulte la sección Solución de problemas a continuación.

Solución de problemas

La pantalla está en blanco o completamente iluminada

Cambie el contraste girando el potenciómetro. Si no se ajusta bien, no podrá leer el texto.

No funciona

Vuelva a comprobar el código, especialmente el que ha incluido en la biblioteca de LCD.

No se muestra la hora correcta

Vuelva a comprobar su código. Es probable que tenga que actualizar la función setTime().

Experimento 21: Usar Bluetooth de baja energía integrado (BLE)

Introducción

Ya estamos en el experimento final y ha vuelto al punto de partida: un solo LED. Esta vez el experimento tiene un giro inesperado. En lugar de hacer que un LED parpadee, lo podrá controlar desde su teléfono o tableta.

La placa 101 tiene Bluetooth de baja energía (BLE) incorporado. Esto significa que puede comenzar a controlar la placa 101 desde su teléfono. La tecnología BLE usa un enfoque basado en servicios/propiedades para establecer comunicación con el dispositivo. Este enfoque facilita el desarrollo en varios dispositivos para usuarios expertos, pero si usted es un nuevo usuario, puede plantear dificultades. En este experimento tendrá que cargar una aplicación en su dispositivo que le ayudará con la comunicación y analizaremos un boceto de ejemplo que usa la tecnología BLE.

Este es el último experimento, pero aún le queda mucho por aprender sobre la placa 101. Le recomendamos encarecidamente que consulte el sitio web de Arduino para obtener más información sobre la placa 101 y cómo han evolucionado y mejorado los materiales de apoyo.

Elementos necesarios

Necesitará los siguientes elementos:

1x placa de pruebas
1x placa Arduino 101 o Genuino 101
1x LED
1x resistencia de 100 Ω
3 cables puente

¿No tiene el SIK?

Si está realizando este experimento y no dispone del SIK, le sugerimos que use estos elementos:

Breadboard - Self-Adhesive (White)

PRT-12002

$5.50

48

Jumper Wires - Connected 6" (M/M, 20 pack)

PRT-12795

$2.10

2

LED - Basic Red 5mm

COM-09590

$0.45

Resistor 100 Ohm 1/4th Watt PTH - 20 pack

COM-13761

Retired

También necesitará una placa Arduino 101 O Genuino 101.

Arduino 101

DEV-13787

9 Retired

Genuino 101

DEV-13984

Retired