Kit P4 Lessons V1-Esp

Kit Pro 4 para plataforma Arduino, con: UNO (tipo DIP)
+ NANO + NodeMCU + Bluetooth

(Favor de verificar el tipo de la tarjeta UNO del Kit adquirido)
Kit Pro 4 para plataforma Arduino, con: UNO (tipo SMD)
+ NANO + NodeMCU + Bluetooth
(Favor de verificar el tipo de la tarjeta UNO del Kit adquirido)
Lecciones de aprendizaje
Para todas las lecciones de este documento usamos una tarjeta UNO R3 compatible. Y en el caso de que tu kit contenga tarjeta
NANO y/o NodeMCU y/o Bluetooth, favor de ver el Anexo 1 con referencias al respecto de sitios web con tutoriales e
información diversa tanto en español como en inglés.
Lección 1 Bienvenido a Arduino
NOTA IMPORTANTE: Si tu Kit contiene la tarjeta UNO del tipo SMD, y si nunca has instalado en tu Windows el controlador o driver para el
Chip CH340, deberás realizar primero lo que se indica en el ANEXO 1 de este documento.
MCU Atmel ATMega328 tipo DIP MCU Atmel ATMega328 tipo SMD
CI o Chip CH340
Esta parte es para los novatos de Arduino. Si ya tienes algún conocimiento sobre Arduino entonces puedes saltarte esta sección.
Arduino es uno de los elementos de hardware de código abierto (Open Source) más populares en todo el mundo. Si no eres un diseñador
electrónico profesional y quieres hacer un proyecto electrónico impresionante por cuenta propia, entonces Arduino es una excelente opción.
Para una comprensión profunda de Arduino puedes visitar la página oficial Sitio web: http:/www.arduino.cc/.
Para esta lección vamos a mostrar cómo escribir el código básico utilizando el lenguaje de programación Arduino. Primero por favor
asegúrate de que ya tienes una tarjeta UNO u otra compatible a la mano. A continuación, instala el entorno de desarrollo de Arduino (IDE)
correcto de acuerdo a tu sistema operativo. EN NUESTRO CASO, todo se muestra para Windows. Descargar Arduino IDE. ¡Ahora, adelante!
• Descarga paso a paso.
1. Paso 1: Conexión del hardware

Conecta tu tarjeta UNO a la PC, con el cable USB.
2. Paso 2: Instalación del controlador (driver) USB
Cuando hagas el paso anterior por primera vez, tu PC debe encontrar un nuevo hardware. A continuación, el sistema instalará el
controlador (driver) USB correspondiente, lo cual podrás comprobar abriendo en Windows lo siguiente: Panel de
Control/Administrador de dispositivos/Puertos (COM y LPT); donde al dar click debe mostrarse “Dispositivo serie USB (COMx), siendo
x un número de uno o dos dígitos que corresponde al valor decimal que Windows le asignó al puerto COM para identificar la tarjeta
UNO o semejante que conectaste.
CONSIDERA que, si estás usando un Windows muy antiguo como por ejemplo el XP, tendrás que hacer una instalación de controlador
manual por medio de la carpeta "... /drivers" de la carpeta Arduino del IDE que ya instalaste. Los detalles están fuera del alcance de
este manual, pero puedes encontrarlos en Internet.
3. Paso 3: Fije un nuevo archivo

Abre tu IDE de Arduino y configura un nuevo archivo (a través de: "Archivo/Nuevo").
4. Paso 4: Escritura de código (programa o sketch como se llama en el ambiente Arduino)
Las siguientes líneas muestran la estructura básica para escribir un código en el IDE de Arduino, usando el "lenguaje de programación
Arduino". Por favor refiérete a esta página web: "http://Arduino.cc/enrEferenciaHomepage" para obtener más información sobre el
lenguaje. Y a continuación aparece un programa básico de ejemplo que puedes copiar y pegar en el IDE:
/*Note:This code is used for Arduino 1.0 or later*/
void setup() {
/*put your setup code here, to run once:*/
Serial.begin(9600); //This is to set the serial port baud rate used to communicate with the computer(or other
MCU that communicate with Arduino)
}
void loop() {
/*put your main code here, to run repeatedly:*/
Serial.println("Welcome to Arduino");
Serial.println("Congratulations, you've done a great job!");
while(1);
}
5. Paso 5 Ejecutando código

Antes de descargar el código de Arduino debes hacer varias cosas en Arduino IDE.
• 1. Seleccionar la tarjeta/placa correcta, por ejemplo Arduino UNO, desde el menú Herramientas/Placa.
• 2. Seleccionar el puerto COM correcto.
• 3. Escribir (o copiar y pegar el programa que deseas ejecutar) y dar click en el botón Verificar (o compilar).
• 4. Dar click en el botón Subir (para que el programa se cargue en la tarjeta Uno o semejante.
Puedes guiarte con las imágenes siguientes paso a paso (estas pueden ser un poco diferentes dependiendo de la versión de IDE).
Si el código se compiló y cargó exitosamente, ahora abre el Monitor Serie (Herramientas/Monitor Serie) para visualizar los mensajes
generados por tu programa. Mostrándose algo semejante a la imagen siguiente:
Lección 2 LED intermitente
En esta lección vamos a utilizar Arduino para controlar un LED que parpadea cada segundo.
• Componentes necesarios
1. 1 x Tarjeta UNO R3
2. 1 x LED de cualquier color
3. 1 x Resistencia de 330 Ω (Ohms)
4. 1 x Protoboard
5. Cables
• Conocimiento necesario
1. Primero debemos saber que un puerto del I/O de Arduino se puede fijar como "entrada" o "salida". Pero no puede ser "Input"
y "Output" al mismo tiempo. Cuando está establecido como "entrada", puede “sentir” el voltaje exterior como "alto" o "bajo".
Cuando está como "salida", transfiere corriente hacia el dispositivo externo, como LED, Zumbador, Actuador, etc. "pinMode()"
es la función para establecer el I/O como" entrada " o como "salida".
2. En segundo lugar, un UNO R3 funciona bajo 5V; y cuando el puerto I/O de salida está en voltaje "alto", dará una salida cercana
al voltaje de trabajo, que es de aproximadamente 5V.
3. Para cada puerto digital de I/O de una tarjeta UNO, puede generarse una corriente de 20mA.
4. LED es la abreviatura en inglés de “diodo emisor de luz”. Tiene dos patitas o pines, uno es ánodo (positivo), el otro es cátodo
(negativo). Para que funcione, el ánodo debe tener un voltaje más alto que el cátodo. Diversas clases de LED tienen diversa
intensidad de iluminación según la corriente que lo atraviesa. Generalmente cada clase de LED tiene una amplia gama de
corriente de trabajo, cuanto más grande es la corriente, más intensa es la iluminación. Podemos utilizar el voltaje de la energía
y una resistencia para controlar la corriente. Normalmente un LED puede trabajar bajo corriente de 10mA. El voltaje en un LED
es básicamente el mismo no importa cuanta corriente fluya; siendo por lo general este valor de 1.9 a 2.1 v para LEDs rojos, 3.0
a 3.4 v para verde y azul, 2.9 a 4.2 v para violeta, rosa, púrpura y blanco.
5. Ya que el I/O de Arduino puede manejar por lo menos 20mA, se podrá utilizar el I/O digital para manejar un LED directamente.
Utilizándose unos 10mA de corriente; agregándose una resistencia al circuito.
6. En esta prueba, vamos a manejar el LED con una corriente de aproximadamente 10mA. El circuito es como la siguiente imagen.
¿Qué valor de resistencia debemos utilizar? Podemos usar la ley Ohm para seleccionar el valor de la resistencia.
I = (Vcc-Veo)/R
En la fórmula anterior, Vcc es el voltaje de salida del I/O cuando emite un voltaje "alto", usaremos 5V aquí. Veo es el voltaje en el LED.
Podemos seleccionar generalmente 2.0 V para un LED rojo (se puede utilizar un multímetro para medirlo o hacer referencia a la hoja de
información del LED). Así, si queremos que el LED funcione con una corriente (I) de aproximadamente 10mA, despejando en la fórmula
anterior y sustituyendo, obtenemos que R = 300 Ω. Por lo que seleccionaremos una resistencia de 330 Ω para nuestro circuito.
• Conexión de hardware
El circuito se muestra a continuación.
• Escritura de código
Para usar una conexión I/O del UNO, primero debemos ponerlo como entrada o salida. Usamos la función pinMode(). Cuando se configura
como entrada, el I/O puede detectar el nivel de voltaje exterior. Cuando se configura como salida, el I/O puede emitir un voltaje “alto o 1” o
un voltaje “bajo o 0”. En este ejemplo, se debe establecer el I/O como salida, entonces se encenderá el LED cuando se emite un voltaje “alto”
por medio de la función digitalWrite().
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
*/
void setup() {
// initialize the digital pin as an output.
pinMode(2, OUTPUT);
}
void loop() {
digitalWrite(2, HIGH); // set the LED on
delay(1000); // wait for a second
digitalWrite(2, LOW); // set the LED off
Carga el código en la tarjeta UNO y podrás que el LED parpadea cada segundo.
Lección 3 Luz en secuencia (rodante)
Esta lección usa el mismo conocimiento de hardware que la anterior. Pero podemos aprender a usar la función repetitiva (de repetición,
cíclica, loop, etc.) "for()". En esta prueba se encenderá un LED por 100 milisegundos, luego se apaga y enciende el siguiente, y luego se apaga y
enciende el siguiente, etc.
2. 8 x LEDs de cualquier color
3. 8 x Resistencias de 330 Ω (Ohms)
4. 1 x Protoboard
5. Cables
Conecta el hardware como se indica a

continuación. Utilizamos los pines I/O de la
tarjeta UNO, D2-D9 para controlar los 8 LEDs.
/*
Blink
Turns on one LED on for 100 milliseconds, then roll to the next one.
*/
int i;
void setup() {
// initialize the digital pin as output.
for(i=2;i<10;i++)
{
pinMode(i, OUTPUT);
}
}
void loop() {
for(i=2;i<10;i++)
{
digitalWrite(i, HIGH); // set the LED on
digitalWrite(i, LOW); // set the LED off
}
}
Lección 4 LED controlado por un botón
Para esta lección, usaremos un botón para controlar el LED. Cuando presionemos el botón el LED estará encendido. Cuando se suelte el botón
el LED se apagará.
4. 1 x Botón (push button)
5. 1 x Protoboard
6. Cables
1. Un puerto I/O de Arduino UNO no sólo puede emitir (salida)
un voltaje "alto" o "bajo"; también puede detectar el voltaje
del exterior. Para utilizar esta función, nosotros debemos
configurar el I/O como "Input" con la función pinMode().
2. Después de que el I/O se fijó como "entrada", podemos
utilizar digitalRead() para leer el voltaje externa.
Basándonos en la conexión de hardware, debemos configurar D2 como Entrada y también debemos activar la resistencia “pull-up” interna.
Así que usaremos INPUT_PULLUP en la función pinMode().
/*Note: This code is used for Arduino 1.0.1 or later*/

/*
Button Controlled LED
Turns on an LED when push the button.
*/
void setup() {
pinMode(2, INPUT_PULLUP);
pinMode(5, OUTPUT);
}
void loop() {
int sensorValue = digitalRead(2);
if(sensorValue)
{
digitalWrite(5, HIGH); // set the LED on
}
else
digitalWrite(5, LOW); // set the LED off
}
Lección 5 PWM Fading (desvanecimiento)
En la lección anterior ya hemos hecho un LED prenda y apague. Pero la fuerza de iluminación es estable. Para esta lección utilizaremos el
método de PWM para cambiar la intensidad de iluminación de un LED, hacemos que la luz vaya de lo oscuro al brillo continuo.
4. 1 x Protoboard
5. Cables
PWM significa Modulación de Ancho de Pulso (Pulse Width Modulation). Es un buen método para obtener resultados analógicos usando
medios digitales. Para algunos componentes que consumen energía como una resistencia que genera calor o un LED que emite la luz u otros
componentes similares, el método de PWM conseguirá un mismo resultado como cuando suministramos un diverso voltaje análogo a los
componentes. Accede por favor a Introducción de PWM para más referencia. En esta
lección vamos a utilizar la función analogWrite() para cambiar la intensidad de la luz del
LED. Ten en cuenta que no todos los pines I/Os de la tarjeta UNO tienen esta función,
esto sólo funciona en el pin 3, 5, 6, 9, 10, y 11 que tienen el símbolo ~.
• Conexión de hardware.
• Conecta el ánodo del LED a la salida digital PIN 9 (D9) en tu UNO, a través de
una resistencia de 330 ohmios. Conecta el cátodo directamente a tierra.
/*
Fade
This example shows how to fade an LED on pin 9

using the analogWrite() function.
This example code is in the public domain.
*/
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
void setup() {
// declare pin 9 to be an output:
pinMode(9, OUTPUT);
}
void loop() {
// set the brightness of pin 9:
analogWrite(9, brightness);
// change the brightness for next time through the loop:

brightness = brightness + fadeAmount;
// reverse the direction of the fading at the ends of the fade:

if (brightness == 0 || brightness == 255) {
fadeAmount = -fadeAmount ;
}
// wait for 30 milliseconds to see the dimming effect
delay(30);
}
Lección 6 LED RGB de varios colores
2. 1 x LED RGB
4. 1 x Protoboard
5. Cables
El LED RGB tiene 3 tipos de Leds (Rojo, verde, azul) integrado en un componente. El LED RGB incluido en tu Kit es un tipo de ánodo común, lo
que significa que los 3 LEDs tienen su ánodo interconectado. El pin más largo es usado de forma común. Podemos utilizar la función que se
desvanece de PWM para cambiar la fuerza de iluminación de cada color LED, porque toda la luz a colores se puede generar a partir de los tres
colores primarios (rojo verde, azul), así que podemos obtener una gama de colores
en esta prueba con el RGB LED.
Asegúrate de que cada LED sea controlado por un puerto/pin PWM (pines 3, 5, 6, 9,
10, o 11). En esta lección usamos D3/D5/D6.
/*
RGB LED Color Changing
This example shows how to change the color of a RGB LED
using the analogWrite() function.
*/
int led1 = 3; // the pin that the LED1 is attached to

// the setup routine runs once when you press reset:
void setup() {
// declare pin 3,5,6 to be an output:
pinMode(led1, OUTPUT);
}
// the loop routine runs over and over again forever:

void loop() {
int i,j,k=0;
for(i=0;i<10;i++)
{
analogWrite(led1, i*25);
for(j=0;j<10;j++)
{
analogWrite(led2, j*25);
for(k=0;k<10;k++)
{
analogWrite(led3, k*25);
delay(10);
}
}
}
}
Lección 7 Advertencia con zumbador
Puede haber dos clases de zumbador en tu kit. Uno se llama zumbador pasivo（se puede ver el PCB verde en él), y el otro es el zumbador
activo (que está totalmente empaquetado y no se puede ver el PCB en él).
Haciendo sonido con zumbador activo.
2. 1 x Zumbador activo
3. 1 x Resistencia de 1k Ω (Ohm)
4. 1 x Resistencia de 10k Ω (Ohms)
5. 1 x Transistor 2N2222 o SS8050 NPN
6. 1 x Protoboard
7. Cables
El zumbador activo tiene circuito oscilante en él. Cuando hay un voltaje suministrado en él, hará un sonido. El zumbador activo en el kit tiene
una tensión (voltaje) nominal de 5V, y una corriente nominal de no más de 30 mA, por lo que generalmente un pin I/O puede operarlo
directamente. Pero para evitar que el I/O se dañe, usaremos un Transistor NPN para amplificar la corriente.
La siguiente imagen muestra cómo se conectado.

/*
Active Buzzer Warning
Make the Buzzer sound for one second, then off for one second, repeatedly.
*/
void setup() {
pinMode(7, OUTPUT);
}
void loop() {
digitalWrite(7, HIGH); // make the Buzzer sound
digitalWrite(7, LOW); // set the Buzzer off
}
Haciendo sonido con zumbador pasivo.
2. 1 x Zumbador pasivo
3. 1 x Resistencia de 1k Ω (Ohm)
4. 1 x Resistencia de 10k Ω (Ohms)
5. 1 x Transistor 2N2222 o SS8050 NPN
6. 1 x Protoboard
7. Cables
El zumbador pasivo no hará un sonido si sólo usamos un voltaje en alto (HIGH) para activarlo. Porque no hay un circuito oscilante en él.
Podemos usar el mecanismo PWM para hacerla zumbar. La Frecuencia resonante del zumbador pasivo en el kit es 2048HZ, el voltaje nominal
también es 5V.
La conexión de hardware es la misma que el ejemplo de sonido del zumbador activo.

• Escritura de la codificación
El siguiente código hará una onda PWM con una frecuencia de aproximadamente 2000HZ. El ciclo de trabajo es de 50%.
/*
Passive Buzzer Warning
Make the Passive Buzzer sound continuously.
*/
void setup() {
pinMode(7, OUTPUT);
}
void loop() {
digitalWrite(7, HIGH); // set D7 HIGH
delayMicroseconds(250);
digitalWrite(7, LOW); // set D7 LOW
}
Lección 8 Lectura analógica de un potenciómetro
A través de esta lección, podemos aprender a utilizar el puerto analógico de la tarjeta UNO, y aprender a utilizar la función analogRead().
2. 1 x Potenciómetro de 1KΩ o de 5KΩ
3. Cables
1. Los puertos/pines A0-A5 de la tarjeta UNO se pueden utilizar como pines analógicos. Estos puertos pueden no solo ser
utilizado como los puertos generales digitales I/O, sino que también pueden leer el voltaje exacto del exterior (0V-5V).
2. Un potenciómetro es una resistencia de tres-terminales con un contacto que gira de forma que crea un divisor de voltaje.
Como se ve en las imágenes siguientes, cuando conectamos el potenciómetro como se muestra, entonces vamos a obtener un
voltaje desde el punto medio. Cuando giramos la perilla, el punto medio dará salida a un voltaje entre 0V-5V. Podemos utilizar
A0-A5 para leer este voltaje, y entonces se podría controlar un cierto dispositivo externo basado en este valor del voltaje.
En este ejemplo, vamos a leer el voltaje analógico analógica del pin central del potenciómetro.
/*
AnalogReadSerial
Reads an analog input on A0, prints the result to the serial monitor

*/
void setup() {
Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(A0);
Serial.println(sensorValue);
}
Carga el código en la tarjeta UNO y obtendrás lo siguiente datos al abrir el Monitor Serie. Si giras la perilla del potenciómetro, entonces el
valor cambiará de 0-1023.
Lección 9 LED controlado por luz
2. 1 x LDR 5516 o 5528
3. 1 x Resistencia de 330 Ω
4. 1 x resistencia de 10k Ω
6. 1 x Protoboard
7. Cables
LDR, que significa resistencia dependiente de luz (Light Dependent Resistor). Su valor cambia por la intensidad de luz externa. Cuanto más
intensa, más pequeño es el valor de la resistencia. En tu kit la LDR se llama GL5516 o GL5528. La siguientes tabla e imagen muestran sus
parámetros. En este experimento controlaremos el LED para encenderlo o apagarlo en base a la intensidad de la luz del ambiente.
GL5516 y GL5528
/*
Light controlled lamps
Reads an analog input on pin 3, then make the LED on or OFF based on the reading.

*/
void setup() {
pinMode(2,OUTPUT);
}
void loop() {
if(sensorValue>500)
{
digitalWrite(2,HIGH);
}
else
digitalWrite(2,LOW);
}
Para el código anterior, el LED estará encendido si pones la LDR en un lugar oscuro (podrías cubrirla con la palma de tu mano. O bien, el LED
se apagará si recibe mucha luz.
Lección 10 Display LED de 8 segmentos
2. 1 x Display LED de 8 segmentos
3. 8 x Resistencias de 330 Ω
4. 1 x Protoboard
5. Cables
1. Un display de ocho segmentos, de hecho, se compone de LEDs
comunes. Hay generalmente dos clases, una es de ánodo común, el
otro es cátodo común. El que está incluido en el kit es de ánodo
común. En el ejemplo siguiente, usaremos el display de ocho
segmentos para mostrar los números 1-9.
2. Sólo tenemos que encender varios LEDs al mismo tiempo para que se
muestre el número.
• Conexión del hardware
/*
1 Digital 8-Segment LED Display
Display the number from 1-9
*/
byte Digital[10]={0xfc,0x60,0xda,0xf2,0x66,0xb6,0xbe,0xe0,0xfe,0xf6};//the character code for number 0-9
void setup()
{
int i=2;
for(i=2;i<10;i++)
{
pinMode(i,OUTPUT);
digitalWrite(i,HIGH);
}
}
void loop()
{
int i=0;
int j;
//Display number 1-9
for(i=0;i<10;i++)
{
//for every number, send the character code to the digital pin
for(j=0;j<8;j++)
{
if(Digital[i]&1<<j)
digitalWrite(9-j,LOW);
else
digitalWrite(9-j,HIGH);
}
delay(500);
}
}
Lección 11 Pantalla de cristal líquido LCD 1602
2. 1 x Pantalla LCD 1602
3. 1 x Potenciómetro de 5 kΩ o 10 kΩ
4. 1 x Protoboard
5. Cables
El lenguaje Arduino tiene una librería (biblioteca) para el LCD que puede soportar todos los LCDs bajo el driver HD44780 (u otros drivers
compatibles). Por favor verifica esta página para más Información: Liquid Crystal Library. Para el LCD 1602 del kit, la descripción de los pines
es la siguiente:
Pin Número Señal Descripción

1 Vss The Power Ground signal,connect to 0V
2 Vdd Power supply,connect to +5V
3 V0 Contrast regulation pin, use an 5K or 10k potentiometer to regulate the contrast
4 RS Data/Command selection
5 R/W Read/Write selection, HIGH for reading, LOW for writing.
6 E LCD enable signal, when changing from HIGH to LOW, the LCD can execute the command.
7-14 A-D7 Data line
15 Bla Back light positive, connect to 5V normaly, 3.3V also works, but a bit dark.
16 Blk Back light negative, connect to ground.
#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12,11,10,9,8,7,6,5,4,3,2);
void setup()
{
lcd.begin(16,2); // set up the LCD's number of columns and rows:
lcd.setCursor(0,0); // set the cursor to column 0, line 0
lcd.print("Welcome"); //// Print a message to the LCD.
lcd.setCursor(0,2); // set the cursor to column 0, line 2
lcd.print("Arduino is Easy"); //Print a message to the LCD.
}
void loop()
{}
Descarga el código y ejecútalo en la tarjeta UNO. El LCD mostrará lo siguiente:

Lección 12 Medición de temperatura
El componente LM35DZ es un sensor que puede medir la temperatura ambiente. Es muy fácil de usar. El que se incluye en el kit es un
LM35DZ y puede medir la temperatura entre 0 °C y + 100 °C.
Conecta el LM35 a la tarjeta UNO, en base a la imagen anterior. Esto es:

GND <=> GND
+ Vs <=> + 5V
Vout<=> A0
• Redacción de código.
/*
Temperature Measurement
Reads an analog input on A0(output from LM35DZ), change it to the real room temperature and print it to serial
monitor.
*/
float powervoltage=5;//define the power supply voltage.
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}
void loop() {
float temperature;
// read the input on analog pin 0:
float sensorValue = analogRead(A0);
// print out the value you read:
temperature=(sensorValue/1023)*powervoltage*100;
Serial.print("The room temperature degree is:");
Serial.println(temperature,1);
delay(1); // delay in between reads for stability
}
Si ahora abres el Monitor Serie podrás ver algo como lo siguiente, mostrando la temperatura ambiental.
Lección 13 Servo motor controlado por PWM
2. 1 x Potenciómetro de 5 kΩ o 10 kΩ
3. 1 x Servo motor SG90
4. Cables
El servo motor se puede controlar a través del PWM. La

frecuencia de la señal de control es 50Hz, la anchura del pulso
positivo controla el ángulo. Para más información detallada
sobre el servo puedes referirte a esta página web: Servo Motor.
Un servo tiene generalmente 3 pines. Para el servo en el kit (un
SG90), el cable rojo es la señal de alimentación y se debe
conectar al voltaje de 5V. El cable marrón es la señal de tierra y
debe conectarse a 0V. El cable naranja es la señal de control y
debe ser alimentado con una señal PWM. Arduino tiene una
"librería de servos" para controlar este tipo de motores. En esta
lección controlaremos la posición del eje a través del
potenciómetro.
// Controlling a servo position using a potentiometer (variable resistor)

#include <Servo.h>
Servo myservo; // create servo object to control a servo
int potpin = 0; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin
void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop()
{
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 179); // scale it to use it with the servo (value between 0 and 180)
myservo.write(val); // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
}
Lección 14 Control de un relevador
2. 1 x Módulo de sensor de sonido
3. 1 x Módulo relevador o relé
5. 1 x Resistencia de 330 Ω
6. 1 x Protoboard
7. Cables
8. Alimentación externa de 3 VCD
Un relevador es un interruptor
electrónico que puede ser controlado por
un MCU. En esta lección vamos a utilizar
el sensor de sonido para controlar el
módulo relevador que actúa como un
interruptor para el LED. Si hay un sonido
fuerte cerca del sensor de sonido, se
emite un valor analógico más alto.
Usamos la tarjeta UNO para leer este
valor, si excede cierto umbral, hará que el
relevador funcione y el LED se encenderá.
En muchos edificios existen lámparas

controladas con relevadores.
/*
Relay controlling
Reads an analog input on pin 0, prints the result to the serial monitor, and use it to control the Relay through
D8
*/
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
pinMode(8,OUTPUT);
}
// the loop routine runs over and over again forever:

void loop() {
// read the input on analog pin 0:
// print out the value you read:
Serial.println(sensorValue);
//If there is a big sound nearby, make the led light for one second.
if(sensorValue>500)
{
digitalWrite(8,HIGH);
delay(1000);
}
else
digitalWrite(8,LOW);
}
Lección 15 Matriz de puntos LED de 8 x 8
1. Introducción
Las matrices de LEDs (o LED arrays) son, como su nombre indica, una matriz de diodos LED normales y corrientes que se comercializa en multitud de
formatos y colores. Desde las de un solo color, a las que tienen varios colores posibles, e incluso las hay de una matriz RGB.
En nuestro caso trabajaremos con una matriz de 8 x 8 LEDs de color rojo
Especificaciones
• LEDs 3mm color rojo.
• Voltaje: 4.7 – 5.3V DC.
• Interfaces para gestionar múltiples módulos en cascada.
• Dimensiones de matriz : 32mm x 32mm x 8mm.
• Dimensiones de PCB : 32mm x 50mm.
2. Pinout
Como se aprecia en la imagen, cuando una fila está en voltaje

HIGH y una columna está en un voltaje LOW, entonces el LED
en el punto de cruce se enciende.
3.Ejemplo
En esta lección, seguiremos utilizando el método de visualización llamado Mecanismo Dinámico de Escaneo,
para hacer que se muestre algo, que es la iluminación de los LEDs fila por fila (de la fila 1 a la fila 8, luego se
repite el proceso). Si el tiempo para un ciclo no es más que 20ms, entonces tu ojo no detectará el parpadeo.
Se conectará el sensor como se muestra en la figura.
/*
8x8 Dot Matrix LED Display
Display four numbers or characters on 8x8 Dot Matrix LED Display
In this sketch, we use D2-D19 to control cathod. And use D10-D17 to control the anode.
*/
int DIG[8]={10,11,12,13,14,15,16,17};//The pins used to controll the anode of the display
byte Wordcode[8]={0XFF,0XE7,0XE7,0XDB,0X81,0XBD,0X7E,0XFF};//the character code for the character or number(it is
the code for "A" here), put your code here
void setup()
{
int i=2;
//Set D2-D17 as OUTPUT
for(i=2;i<18;i++)
{
pinMode(i,OUTPUT);
digitalWrite(i,HIGH);
}
}
void loop()
{
int j;
int k=0;
//Display ROW1-ROW8
for(k=0;k<8;k++)
{
digitalWrite(DIG[k],HIGH);//Set DIG[K] to be ON.
//display ROW(k)
for(j=0;j<8;j++)
{
if(Wordcode[k]&1<<j)
digitalWrite(9-j,HIGH);
else
digitalWrite(9-j,LOW);
}
digitalWrite(DIG[k],LOW);
}
}
El resultado será como el de la imagen siguiente:
Lección 16. Manejo de un Motor a Pasos (Step Motor / Stepper motor)
1. Introducción
Un motor a pasos (o, paso a paso) es un dispositivo electromecánico que convierte pulsos eléctricos en movimientos mecánicos discretos. El
eje de un motor a pasos gira en incrementos discretos cuando impulsos de mando eléctrico se aplican a él en la secuencia correcta.
La secuencia de los pulsos aplicados se relaciona directamente con la dirección de rotación de ejes motor. La velocidad de la rotación de los
ejes motor está directamente relacionada con la frecuencia de los pulsos de entrada y la duración de la rotación está directamente
relacionada con el número de pulsos de entrada aplicada.
Una de las ventajas más importantes de un motor paso a paso es su capacidad para ser controlado con precisión en un sistema de lazo
abierto. Control de lazo abierto significa que ninguna información de retroalimentación de posición es necesario. Este tipo de control elimina
la necesidad de costosos dispositivos de detección y regeneración como codificadores ópticos.
Especificaciones
El motor paso a paso del kit es 28BYJ-48 y los parámetros del motor paso a paso son:
• Modelo: 28BYJ-48
• Tensión nominal de entre 5V y 12 V.
• 4 Fases.
• Resistencia 50 Ω.
• Par motor de 34 Newton / metro más o menos 0,34 Kg por cm.
• Consumo de unos 55 mA.
• 64 pasos por vuelta (con medios pasos).
• Reductora de 1 / 64.
• Ángulo de paso: 5,625 °
• Frecuencia: 100Hz
• Resistencia de la C.C.: 50Ω±7 %(25 ° C)
• En tracción par > 34.3mN.m(120Hz)
• Posicionamiento automático par > 34.3mN.m
• Par de fricción: 600-1200 gf.cm
• Resistencia de aislamiento > 10MΩ(500V)
• Aislantes de electricidad : 600VAC/1mA/1s
• Grado de aislamiento : A
• Subida de temperatura < 40K(120Hz)
• Ruido < 35dB (120Hz, No carga, 10cm)
2. Pinout
Como la tabla anterior muestra (switching sequence), hay 8 pasos diversos (estos 8 pasos
son uno ciclo de paso) para que el motor de pasos avance. Cada paso hará que el eje gire
con un ángulo de 5.625/64 grados. Así, si queremos que el eje gire un círculo, entonces el
ciclo de paso hacer: 360/(8 * 5.625/64) = 512 (ciclos de paso). El código siguiente hará
que el movimiento de pasos se mueve en el sentido de las manecillas un círculo, y luego
se mueva un círculo contra manecillas
El 28BYJ-48 tiene un paso de 5.625 grados (64 pasos por vuelta

usando half-step). El reductor interno tiene una relación de 1/64.
Combinados, la precisión total es de 4096 pasos por vuelta,
equivalente a un paso de 0.088º, que es una precisión muy
elevada.
Driver ULN2003, para manejo del motor
• Tamaño: 42mmx30mm
• Chip de controlador de uso ULN2003, 500mA
• LEDs A, B, C, D indica las cuatro fases las condiciones de
trabajo motor paso a paso.
• Conector blanco estándar motor paso a paso.
• Pines de alimentación separados
Conexiones de la placa de driver:
3.ejemplo
En este ejemplo se
conectará el sensor
como se muestra
en la figura:
• Escritura de código. Ejemplo 1 sin uso de librería:
/*
Stepper Motor Control - one revolution
This program drives a unipolar stepper motor.

The motor is attached to digital pins 8 - 11 of the Arduino.
The motor should revolve one revolution in one direction, then

one revolution in the other direction.
*/
void setup() {
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
}
void loop() {
int i=0;
//revolve one revolution clockwise
for(i=0;i<512;i++){
clockwiserotate();}
//revolve one revolution counterclockwise
for(i=0;i<512;i++){
counterclockwiserotate();}
}
void clockwiserotate() { //revolve clockwise
step1();
step2();
step3();
step4();
step5();
step6();
step7();
step8();
}
void counterclockwiserotate() { //revolve counterclockwise
step1();
step7();
step6();
step5();
step4();
step3();
step2();
step1();
}
void step1(){
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
delay(2);
}
void step2(){
delay(2);
}
void step3(){
delay(2);
}
void step4(){
delay(2);
}
void step5(){
delay(2);
}
void step6(){
delay(2);
}
void step7(){
delay(2);
}
void step8(){
delay(2);
}
• Escritura de código. Ejemplo 2 con uso de librería Stepper:
La otra manera de programar un motor 28BYJ-48 es utilizar la librería Stepper que viene incluida con el entorno de desarrollo oficial de
Arduino. Esta librería nos facilita el uso de este tipo de motores y viene adaptada para motores bipolares. En este caso la librería Stepper usa
el modo de paso completo en lugar del medio paso, teniendo un número de pasos por vuelta de 2048.
NOTA: Recomendamos visitar la liga https://programarfacil.com/blog/motor-paso-a-paso/ que

contiene un tutorial muy interesante sobre diversas formas de programar este tipo de motor, bajo la
Plataforma Arduino.
Llevando esta secuencia de encendido a una tabla, que posteriormente usaremos para el código, la secuencia quedaría de la siguiente forma:
Paso A B A’ B’
1 ON OFF OFF OFF
2 OFF ON OFF OFF
3 OFF OFF ON OFF
4 OFF OFF OFF ON
Código para mover el motor:
// Incluímos la librería para poder utilizarla

#include <Stepper.h>
// Esto es el número de pasos por revolución

#define STEPS 4096
// Número de pasos que queremos que de
#define NUMSTEPS 100
// Constructor, pasamos STEPS y los pines donde tengamos conectado el motor

Stepper stepper(STEPS, 8, 9, 10, 11);
void setup() {
// Asignamos la velocidad en RPM (Revoluciones por Minuto)
stepper.setSpeed(5);
}
void loop() {
// Movemos el motor un número determinado de pasos
stepper.step(NUMSTEPS);
delay(2000);
}
NOTA RELEVANTE SOBRE EL KIT:
Los ejemplos aquí contenidos, son solamente una muestra de lo que se podría realizar con los módulos del Kit de 37 sensores y los sensores más los
componentes extra.
Si deseas obtener más información técnica, debes recordar que por el hecho de ser una plataforma Open Source encontrarás gran cantidad de
información en Internet, principalmente en inglés por ser el idioma de la Ciencia y la Tecnología para cualquier persona que aporta desde cualquier país en
el mundo, y “sube” sus proyectos a Internet en ese idioma para tener mayores probabilidades de ser leído en cualquier parte del planeta.
Por ejemplo, las hojas técnicas o datasheets de los componentes individuales de los diversos módulos casi siempre están solamente en inglés. Las cuales
suelen contener información muy detallada y especializada a niveles intermedios y avanzados.
De ahí que, si haces las búsquedas adecuadas (también puedes encontrar información en español) verás que podrás hacer prácticas o proyectos no
solamente con los módulos de forma individual, sino también juntando varios de ellos y/o también en conjunto con otros kits complementarios que hay en
el mercado.
Todo dependerá de: tu creatividad, tus conocimientos previos, tu capacidad de adquirir nuevos conocimientos y de los objetivos que te traces.
En INGENIERÍA ISE-AR te deseamos muchas horas de entretenimiento, aprendizaje útil y creativo disfrutando estas maravillosas plataformas; donde el
límite está en ti.
¡MUCHAS GRACIAS!
ANEXO 1, con referencias para:
Tarjeta UNO con microcontrolador en formato SMD
y Chip CH340
La tarjeta UNO con el microcontrolador ATMega328 tipo SMD y con el Circuito Integrado CH340 para la interfaz a puesto USB funciona
como la tarjeta UNO con el microcontrolador tipo DIP en socket.
El chip (CI o IC) CH340 (o CH340G) sirve para la interfaz con el puerto USB de la computadora donde se conectará/programará; el cual
reemplaza los FT232RL o el ATMegaA16u2 de otras tarjetas UNO.
Y cuando alguna tarjeta (UNO, NANO, MEGA 2560 u otras) contienen dicho chip, se requiere instalar previamente un driver para que el
puerto sea reconocido por los USB de la computadora bajo Windows 10. (A veces el Windows 10, por diversas circunstancias, ya tiene
instalado el driver).
Para instalarlo, y configurarlo descarga el siguiente archivo desde el sitio oficial del creador del chip CH340 en China:
http://www.wch.cn/download/CH341SER_EXE.html donde se verá algo como lo siguiente:
Da clic en la franja azul donde aparece un ícono

de una nube con una flecha hacia abajo.
Una vez descargado y antes de ejecutarlo,
DEBES CONECTAR la tarjeta UNO a un
puerto USB (te recomendamos mucho que
abras la ventana de “Administrador de
dispositivos” en el Panel de Control para
que veas lo que va sucediendo), y entonces
corres el archivo EXE dando doble clic sobre
él.
Se abrirá una ventana como la del lado
derecho, y das clic en INSTALL.
Al terminar de instalarse el driver CH340, en la ventana del “Administrador de dispositivos” deberá aparecer algo como lo siguiente:
Donde se confirma que Windows 10 ha reconocido el dispositivo con CH340 (el UNO en este caso) y que puede trabajar conectado al puerto
USB de la computadora como puerto serial COMx (COM4 en este ejemplo).
Posteriormente deberás entrar al IDE de Arduino, el cual ya habrás descargado e instalado adecuadamente desde el sitio oficial de Arduino,
con las configuraciones adecuadas para el Windows 10 de tu computadora y en el idioma que hayas seleccionado. Recordando que lo
recomendable es tener la última versión, aunque también es posible descargar e instalar versiones anteriores del IDE que el sitio oficial sigue
poniendo a disposición de los usuarios en todo el mundo.
Ya instalado y funcionando crrectamente el IDE de Arduino, deberás configurar la tarjeta UNO de forma semejante a lo mostrado en la
imagen siguiente:
En el IDE de Arduino entras al menú Herramientas, seleccionas el Puerto: “COMx” (COM4 en este ejemplo), seleccionas la Placa: “Arduino
Uno” y ¡listo! El UNO ya puede ser programado desde este IDE.
Cabe señalar que, con la instalación del driver CH340 también se podrán utilizar otras tarjetas que lo usan (en ciertos diseños), como: el
NANO, el MEGA2560, NodeMCU y otras compatibles.
ANEXO 2, con referencias para:
NANO + NodeMCU + Bluetooth
1) La tarjeta NANO funciona básicamente de la misma forma que la UNO; con otras dimensiones (form factor) está diseñada para
colocarse en un protoboard o en algunos Shields especiales para estas tarjetas, de manera que pueda conectarse con otros
componentes.
En el caso de nuestros Kits, normalmente manejamos una como la siguiente (puede haber pequeñas diferencias físicas pero
funcionalmente sería igual):
CI o IC CH340
Donde cabe notar que contiene un chip (CI o IC) CH340 (o CH340G) que sirve para la interfaz con el puerto USB de la computadora
donde se conectará/programará la NANO; el cual reemplaza los FT232RL o el ATMegaA16u2 de otros diseños.
Y cuando alguna tarjeta (NANO, MEGA 2560 u otras) contiene dicho chip, se requiere instalar previamente un driver para que el
puerto sea reconocido por los USB de la computadora bajo Windows 10. (A veces el Windows 10, por diversas circunstancias, ya tiene
instalado el driver).
Descarga el archivo siguiente desde el sitio oficial del creador del chip en China:
http://www.wch.cn/download/CH341SER_EXE.html donde se verá algo como lo muestra la imagen:
Da clic en la franja azul donde aparece un ícono de una nube con una flecha hacia abajo. Una vez descargado y antes de ejecutarlo,
DEBES CONECTAR la tarjeta NANO a un puerto USB (te recomendamos
mucho que abras la ventana de “Administrador de dispositivos” en el Panel
de Control para que veas lo que va sucediendo), y entonces corres el archivo
EXE dando doble clic sobre él.
Se abrirá una ventana como la del lado derecho, y das clic en INSTALL.
Al terminar de instalarse el driver CH340, en la ventana del “Administrador de dispositivos” deberá aparecer algo como lo siguiente:
Donde se confirma que Windows 10 ha reconocido el dispositivo con CH340 (el NANO en este caso) y que puede trabajar conectado al
puerto USB de la computadora como puerto serial COMx (COM3 en este ejemplo).
Una vez configurado el puerto USB-SERIAL, en el IDE de Arduino entras al menú Herramientas (imagen previa), seleccionas el Puerto:
“COMx” (COM3 en este ejemplo), seleccionas la Placa: “Arduino Nano” y seleccionas Procesador “Atmega328P (Old Bootloader)”. Y
¡listo! El NANO ya puede ser programado desde el IDE de Arduino.
Cabe señalar que, con la instalación del driver CH340 también se podrán utilizar otra tarjetas que lo usan (en ciertos diseños), como: el
UNO, el MEGA2560 y otras compatibles.
2) La tarjeta NodeMCU basada en ESP8266 (la plataforma ESP8266 es una popular y muy usada plataforma de tarjetas con
microcontroladores con WiFi) permite la integración con redes WiFi estándar. Por sí misma, al contener un microcontrolador, es una
tarjeta para programación y desarrollo de infinidad de proyectos; pudiendo trabajar en conjunto o en combinación con tarjetas de la
plataforma Arduino como la UNO, NANO, MEGA 2560, etc.
De hecho, por sus características y capacidades, se usa en muchas ocasiones como la tarjeta principal de proyectos de Internet de las
Cosas (IoT por sus siglas en inglés).
Por lo anterior, y aunque se puede probar con el tradicional “Hola Mundo” de estas plataformas, que en el caso de la programación
física es el programa Blink (LED intermitente), su uso para aprovechar las excelentes características que tiene al manejar WiFi (puede
también utilizarse en proyectos sin WiFi), requiere que el usuario tenga un nivel de conocimientos intermedios a
avanzados. Entre otras cosas, puede configurarse y programarse desde el IDE de Arduino, otros IDEs con Micropython, con LUA, etc.
Hay varias versiones del NodeMCU. La que incluimos en nuestros kits es la llamada 3a generación V1.0 / V3, que por cierto, también
usa el chip CH340.
Como todas estas plataformas, hay infinidad de referencias en Internet principalmente en inglés para que sea mayor su penetración
en cualquier país del mundo y en menor medida en otros idiomas. Y en nuestro caso, como una muestra te lo que podrás encontrar,
te dejamos unas ligas de sitios en español y en inglés sobre los NodeMCU:
https://www.luisllamas.es/esp8266-nodemcu/
https://www.esploradores.com/comparacion-de-placas-nodemcu_/ En esta hay muchas secciones que es recomedable las sigas y
estudies con cuidado. La cantidad de información es muy amplia y detallada.
https://programarfacil.com/esp8266/como-programar-nodemcu-ide-arduino/
https://create.arduino.cc/projecthub/najad/using-arduino-ide-to-program-nodemcu-33e899
https://randomnerdtutorials.com/projects-esp8266/
¡Que te diviertas y aprendas mucho con el NodeMCU!, una maravillosa plataforma bajo ESP8266.
3) La tarjeta o módulo Bluetooth HC-05 que se incluye en algunos de nuestros kits, te dan la posibilidad de entrar al fabuloso
mundo de la conectividad e interacción inalámbrica bajo este estandar mundial (el Bluetooth).
Podrás hacer infinidad de proyectos controlando dispositivos, componentes, sensores, actuadores, etc. de forma inalámbrica desde y
hacia la tarjeta UNO o la NANO o algún otra; ya sea de forma independiente en estas plataformas o por medio de interacción, por
ejemplo, con un smartphone o una laptop que tengan habilitada esta modalidad de comunicación y que tengan las aplicaciones
correspondientes. Por ejemplo en smartphones Android ya hay muchas Apps que permiten conectarte a alguna tarjeta UNO u otras
que estén habilitatdes con algún módulo Bluetooth. O si tienes los conocimientos suficientes podrías desarrollar tus propias Apps.
Y al igual que con el NodeMCU, hay gran cantidad de referencias en Internet, principalmente en ingles pero también en otros idiomas.
Cabe hacer notar que desde hace años han existido estos dos tipos de módulos Bluetooth, el HC-05 y el HC-06 (hoy en día hay otros también).
El HC-05 es transmisor y receptor y el HC-06 solamente es receptor. Si tu kit contiene módulo Bluetooth, sería el HC-05 que hemos manejado
desde hace tiempo.
La forma básica de uso, pero también la más especializada es por medio de comandos “AT”; lo cual requiere que seas un usuario intermedio a
avanzado de la plataforma Arduino. Y la otra sería con aplicaciones Apps ya desarrolladas que te faciliten la interacción entre la programación
física de Arduino y un smartphone, tablet, etc.
Algunas referencias que te proporcionamos, son:

https://create.arduino.cc/projecthub/akshayjoseph666/interfacing-bluetooth-module-hc-05-with-arduino-uno-f5209b Esta referencia
esta en inglés, pero si no comprendes este idioma en su foma técnica, recuerda que: Windows 10, los navegadores web, el MS Ofiice y otras
herramientas permiten hacer traducciones al español.
En esta referencia se interactúa con una App para Android.
https://smelpro.com/blog/modulo-hc-05/ Referencia muy interesante que permite hacer el encendido y apagado de un LED desde
una App en Android que tú mismo podrás crear con la plataforma de desarrollo libre de Apps “MIT APP INVENTOR” (requiere conocimientos
previos suficientes de parte del usuario para estos desarrollos).
https://www.youtube.com/watch?v=kSl8SUb5L9A Tutorial en Youtube donde se usa una App Andoid para manejar un par de LEDs.
Dicha App se preprograma por el usuario para configurarla de acuerdo a sus requerimientos o deseos en el manejo de estos LEDs.
Cabe mencionar que hay usuarios con los conocimientos suficientes que les permiten hacer estas prácticas/proyectos directamente como se
explica en el tutoiral. Y otros requieren primero: probar, comprender y realizar tutoriales como el de la liga siguiente. Antes de hacer el de la
App con los LEDs.
https://www.youtube.com/watch?v=5SmKOUHhmWk Tutorial en Youtube que explica comunicación por comandos AT (es del mismo
autor de la referncia anterior)
https://www.youtube.com/watch?v=Yz5A4t2hMbo Tuorial en Youtube que incluye imágenes y diagramas de conexión, el programa
(sketch para Arduino) y el archivo con la App.
Nuevamente enfatizamos que hay infinidad de referencias en Internet para la plataforma Arduino más otras de Physical Computing,
principalemnte en inglés, pero también en español. Dependiendo del tiempo que disponga el usuario, sus conocimientos previos y sus
capacidades para adquirir nuevos conocimientos, podrá encontrar y utilizar una inagotable fuente de información en Internet aemás de
bibliografía (hay muchos muy buenos libros en inglés y algunos en español) acerca de todos estos temas y muchos más.
Te deseamos muchísimas horas de diversión y aprendizaje con estas maravillosas plataformas de la llamada Computació Física (Physical
Computing).
Tus amigos de INGENIERÍA ISE-AR

Kit P4 Lessons V1-Esp

Cargado por

Copyright:

Formatos disponibles

Kit P4 Lessons V1-Esp

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Kit P4 Lessons V1-Esp

Cargado por

Copyright:

Formatos disponibles

Kit Pro 4 para plataforma Arduino, con: UNO (tipo DIP)

+ NANO + NodeMCU + Bluetooth

Lección 1 Bienvenido a Arduino

• Descarga paso a paso.

1. Paso 1: Conexión del hardware

3. Paso 3: Fije un nuevo archivo

/*Note:This code is used for Arduino 1.0 or later*/

5. Paso 5 Ejecutando código

El circuito se muestra a continuación.

Conecta el hardware como se indica a

/*Note: This code is used for Arduino 1.0.1 or later*/

This example shows how to fade an LED on pin 9

This example code is in the public domain.

// change the brightness for next time through the loop:

// reverse the direction of the fading at the ends of the fade:

int led1 = 3; // the pin that the LED1 is attached to

// the loop routine runs over and over again forever:

Haciendo sonido con zumbador activo.

La siguiente imagen muestra cómo se conectado.

Haciendo sonido con zumbador pasivo.

La conexión de hardware es la misma que el ejemplo de sonido del zumbador activo.

This example code is in the public domain.

This example code is in the public domain.

Pin Número Señal Descripción

Descarga el código y ejecútalo en la tarjeta UNO. El LCD mostrará lo siguiente:

Conecta el LM35 a la tarjeta UNO, en base a la imagen anterior. Esto es:

El servo motor se puede controlar a través del PWM. La

// Controlling a servo position using a potentiometer (variable resistor)

En muchos edificios existen lámparas

// the loop routine runs over and over again forever:

Como se aprecia en la imagen, cuando una fila está en voltaje

El 28BYJ-48 tiene un paso de 5.625 grados (64 pasos por vuelta

Driver ULN2003, para manejo del motor

This program drives a unipolar stepper motor.

The motor should revolve one revolution in one direction, then

• Escritura de código. Ejemplo 2 con uso de librería Stepper:

NOTA: Recomendamos visitar la liga https://programarfacil.com/blog/motor-paso-a-paso/ que

1 ON OFF OFF OFF

2 OFF ON OFF OFF

3 OFF OFF ON OFF

4 OFF OFF OFF ON

Código para mover el motor:

// Incluímos la librería para poder utilizarla

// Esto es el número de pasos por revolución

// Constructor, pasamos STEPS y los pines donde tengamos conectado el motor

Da clic en la franja azul donde aparece un ícono

Algunas referencias que te proporcionamos, son:

Tus amigos de INGENIERÍA ISE-AR

También podría gustarte

/Note:This code is used for Arduino 1.0 or later/

/Note: This code is used for Arduino 1.0.1 or later/