El «Sistema embebido» es el nombre genérico que reciben los equipos electrónicos que incluyen un procesamiento de datos, pero que, a diferencia de una computadora, están diseñados para satisfacer una función específica, como en el caso de un reloj digital, un reproductor de MP3, un teléfono celular, una impresora, el sistema de control de un automóvil, de un satélite o de una planta nuclear. Es un sistema electrónico que está contenido («embebido») dentro de un equipo completo que incluye, por ejemplo, partes mecánicas y electromecánicas.
Los sistemas embebidos están optimizados para reducir su tamaño y su costo, aumentar su confiabilidad y mejorar su desempeño. Su cerebro es típicamente un microcontrolador, aunque los datos también pueden ser procesados por un DSP, una FPGA, o un ASIC. Algunas aplicaciones también tienen requisitos de bajo consumo, como por ejemplo un teléfono celular, que se satisfacen gracias a los avances en la tecnología.
Laboratorio #1: Controlar 8 LEDs desde el Arduino, un LED encendido que se mueve en forma continua de izquierda a derecha y viceversa.
Descripción:
En este primer laboratorio se realizara el control de leds por medio de un micro controlador (ARDUINO),
Para esta primera practica el procedimiento es encender y apagar 8 leds de manera secuencial mediante 8 salidas digitales del Arduino, estos leds tendrán un recorrido de derecha a izquierda y viceversa, el tiempo que se demora en encender y apagar está definido por el usuario en el software (100 milisegundos) con la posibilidad de cambiarlo de acuerdo a la necesidad.
Materiales:
Los materiales que usaremos para este primer laboratorio son los siguientes:
8 resistencias
1 Plataforma Arduino UNO o MEGA
1 ProtoBoard
8 Leds 5mm
Diagrama:
ProtoBoard:
Esquemático:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este primer laboratorio.
Paso 2: Ubicar las resistencias en la ProtoBoard.
Paso 3: Ubicar los leds en la ProtoBoard.
Nota:
– La pata más larga del diodo LED es el polo positivo (ánodo).
– La pata más corta del diodo LED es el polo negativo (cátodo).
Paso 4: conectar el Arduino con los leds en la ProtoBoard.
En el Ardunio ubicar donde nos dice Digital (PWM) que serían las salidas digitales en donde usaremos los pines del 2 al 9 para los leds.
En el mismo rango encontraremos el pin GND (Tierra) que ira a la ProtoBoard donde se encuentran nuestras resistencias.
Código Arduino:
#define maxleds 8 //creamos la variable maxleds de 8 elementos
int led[maxleds] = {2,3,4,5,6,7,8,9}; //creamos un vector de enteros para los pines a utilizar
void setup () //Esta función se ejecutará una única vez después de que se conecte la placa Arduino a la fuente de alimentación, o cuando se pulse el botón de reinicio de la placa.
{
for (int i=0;i<maxleds;i++)
pinMode(led[i],OUTPUT); //configura los pines de los LEDS como salida.
}
// se ejecuta consecutivamente, permitiéndole al programa variar y responder.
void loop()
{
for (int i=0;i<=maxleds;i++) // ciclo for para cambiar de salida derecha
{
prender(led[i],100); //llama a la funcion prender, pasando como parametro el arreglo y el tiempo
apagar(led[i],100); //llama a la funcion apagar, pasando como parametro el arreglo y el tiempo.
}
for (int i=maxleds;i>=0;i--) // ciclo for para cambiar de salida izquierda
{
prender(led[i],100); //llama a la funcion prender ingresando los parametros
apagar(led[i],100); //llama a la funcion apagar ingresando los parametros}
}
}
void prender(int i, int t) //Declaramos la funcion para enceder el led
{
digitalWrite(i, HIGH);//led esta encendido
delay(t); //tiempo de encendido
}
void apagar(int i, int t) //Declaramos LA funcion para apagar el led
{
digitalWrite(i, LOW); //led esta apagado
delay(t); //tiempo de apagado
}
Laboratorio #2: controlar 8 LEDs desde Arduino, un LED encendido que se mueve de izquierda a derecha según la posición del Potenciómetro.
Descripción:
En este segundo laboratorio se realizara el control de leds por medio de un micro controlador (ARDUINO) y un Potenciómetro.
Para esta segunda práctica el procedimiento es encender y apagar 8 leds de manera secuencial mediante 8 salidas digitales del Arduino, pero estas salidas serán controladas por un valor análogo del potenciómetro, estos leds tendrán un recorrido de derecha a izquierda y viceversa.
Materiales:
Los materiales que usaremos para este segundo laboratorio son los siguientes:
8 resistencias
1 Plataforma Arduino UNO o MEGA
1 ProtoBoard
8 Leds 5mm
1 Potenciómetro 10K
Diagrama:
ProtoBoard:
Esquemático:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este primer laboratorio.
Paso 2: Ubicar las resistencias en la ProtoBoard.
Paso 3: Ubicar los leds en la ProtoBoard.
Nota:
La pata más larga del diodo LED es el polo positivo (ánodo).
La pata más corta del diodo LED es el polo negativo (cátodo).
Paso 4: conectar el Arduino con los leds y el potenciómetro en la ProtoBoard.
En el Ardunio ubicar donde nos dice Digital (PWM) que serían las salidas digitales en donde usaremos los pines del 2 al 9 para los leds.
En el mismo rango encontraremos el pin GND (Tierra) que ira a la ProtoBoard donde se encuentran nuestras resistencias.
-Conectar el potenciómetro de 10k a la placa Arduino, el pin del medio del potenciómetro se conecta al pin análogo A0 y los otros dos uno es el GND (Tierra) y el otro ira conectado al pin 5V.
Código Arduino:
#define maxleds 8 //creamos la variable maxleds de 8 elementos
#define pot A0 //creamos una variable pot con el pin A0
int led[maxleds] = {2,3,4,5,6,7,8,9}; //creamos un vector para los pines a utilizar
// Solo se ejecuta una vez, al iniciar o resetear el Arduino
void setup ()
{
Serial.begin(9600); // La comunicacion serial sera a 9600 baudios
for (int i=0;i<maxleds;i++)
pinMode(led[i],OUTPUT); // Definimos los pines del 2 al 9 como salida
}
// Ciclo
void loop()
{
int valor = analogRead(pot); // lee el valor del potenciometro
int i=map(valor, 0, 1023, 0, 7); // hace un mapeo o conversion
prender(led[i],500); //llama a la funcion prender ingresando los parametros
apagar(led[i],100); //llama a la funcion apagar ingresando los parametros
Serial.print(i); // imprime por el puero serial el valor de i
}
void prender(int i, int t) //funcion para enceder el led
{
digitalWrite(i, HIGH);//led esta encendido
delay(t); //tiempo de encendido
}
void apagar(int i, int t)
{
digitalWrite(i, LOW);//led esta apagado
delay(t); //tiempo de apagado
}
Laboratorio #3: Controlar 8 LEDs desde el Arduino, un LED encendido que se mueve en forma continua de izquierda a derecha, usando los valores de dos Potenciómetros para controlar los tiempos que el LED permanece encendido y apagado.
Descripción:
En este segundo laboratorio se realizara el control de LEDs por medio de un micro controlador (ARDUINO) y dos Potenciómetros.
Para esta tercera práctica el procedimiento es encender y apagar 8 leds mediante dos pines análogos donde se controlaran los tiempos de encendido y apagado desde los dos potenciómetros
Materiales:
Los materiales que usaremos para este segundo laboratorio son los siguientes:
8 resistencias
1 Plataforma Arduino UNO o MEGA
1 ProtoBoard
8 Leds 5mm
2 Potenciómetro 10K
Diagrama:
ProtoBoard:
Esquemático:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este laboratorio.
Paso 2: Ubicar las resistencias en la ProtoBoard.
Paso 3: Ubicar los leds en la ProtoBoard.
Nota:
La pata más larga del diodo LED es el polo positivo (ánodo).
La pata más corta del diodo LED es el polo negativo (cátodo)
Paso 4: conectar el Arduino con los leds y los dos potenciómetros en la ProtoBoard.
En el Ardunio ubicar donde nos dice Digital (PWM) que serían las salidas digitales en donde usaremos los pines del 2 al 9 para los leds.
En el mismo rango encontraremos el pin GND (Tierra) que ira a la ProtoBoard donde se encuentran nuestras resistencias.
Conectar los dos potenciómetros de 10k a la placa Arduino, los pines del medio de los potenciómetros se conectan al pin análogo A0 y A1 los otros dos son el GND (Tierra) y el otro ira conectado al pin 5V.
Código Arduino:
#define maxleds 8 //creamos la variable maxleds de 8 elementos
#define pot1 A0 //creamos la variable pot con el pin A1
#define pot2 A1 //creamos la variable pot con el pin A2
int led[maxleds] = {2,3,4,5,6,7,8,9}; //creamos un vector para los pines a utilizar
void setup ()
{
Serial.begin(9600);
for (int i=0;i<maxleds;i++)
pinMode(led[i],OUTPUT); // Los pines del 2 al 9 seran de salida
}
void loop()
{
for (int i=0;i<=maxleds;i++)
{
int timeon = analogRead(pot1); // lee el valor del potenciometro 1
int t1=map(timeon, 0, 1023, 0, 1000); // hace un mapeo o conversion
int timeoff = analogRead(pot2); // lee el valor del potenciometro 2
int t2=map(timeoff, 0, 1023, 0, 1000); // hace un mapeo o conversion
prender(led[i],t1); //llama a la funcion prender ingresando los parametros
apagar(led[i],t2); //llama a la funcion apagar ingresando los parametros
}
for (int i=maxleds;i>=0;i--)
{
int timeon = analogRead(pot1); // lee el valor del potenciometro 1
int t1=map(timeon, 0, 1023, 0, 1000); // hace un mapeo o conversion
int timeoff = analogRead(pot2); // lee el valor del potenciometro 2
int t2=map(timeoff, 0, 1023, 0, 1000); // hace un mapeo o conversion
prender(led[i],t1); //llama a la funcion prender ingresando los parametros
apagar(led[i],t2); //llama a la funcion apagar ingresando los parametros
}
}
void prender(int i, int t) //funcion para enceder el led
{
digitalWrite(i, HIGH);//led esta encendido
delay(t); //tiempo de encendido
}
void apagar(int i, int t)
{
digitalWrite(i, LOW);//led esta apagado
delay(t); //tiempo de apagado
}
Quinto Ejercicio:
Controlar un LED RGB desde el Arduino, vía PWM con 3 potenciómetros, uno para cada color.
Descripción:
En este quinto laboratorio se controlara un Led RGB por medio del ARDUINO.
Para este laboratorio el procedimiento es controlar la intensidad de cada uno de los colores primarios (rojo, verde y azul) para generar diferentes combinaciones de colores.
Materiales:
Los materiales que usaremos para este quinto laboratorio son los siguientes:
3 — resistencias
3 — potenciómetros 10k
1 — Plataforma Arduino UNO o MEGA
1 — ProtoBoard
1 — Led RGB
Diagrama: ProtoBoard:
Esquematico:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este quinto laboratorio.
Paso 2: Ubicar las resistencias en la ProtoBoard.
Paso 3: Ubicar los potenciómetros en la ProtoBoard y el Led.
Paso 5:
Conectar el Arduino con el led RGB y los potenciómetros.
Conectar las entradas analogas provenientes de los potenciómetros a los pines análogos del Arduino (A0, A1 y A2).
Conectar las salidas PWM (9 (rojo), 10 (verde), 11 (azul)) del arduino, a los pines del led RGB mediante las resistencias.
CODIGO ARDUINO:
#define maxleds 3 //creamos la variable maxled 3 elementos
#define pot0 A0 //creamos la variable pot con el pin A0
#define pot1 A1 //creamos la variable pot con el pin A1
#define pot2 A2 //creamos la variable pot con el pin A2
int led[maxleds] = {9,10,11}; //creamos un vector para los pines a utilizar
int valor1=0; //creamos la variable valor 1 de tipo entero
int valor2=0;
int valor3=0;
void setup ()
{
Serial.begin(9600);
for (int i=0;i<maxleds;i++)
pinMode(led[i],OUTPUT); // los pines del 3,5,6 seran de salida
}
void loop()
{
int rojo = analogRead(pot0); // lee el valor del potenciometro 0
int valor1=map(rojo, 0, 1023, 0, 255); // hace un mapeo o conversion
int verde = analogRead(pot1); // lee el valor del potenciometro 1
int valor2=map(verde, 0, 1023, 0, 255); // hace un mapeo o conversion
int azul = analogRead(pot2); // lee el valor del potenciometro 2
int valor3=map(azul, 0, 1023, 0, 255); // hace un mapeo o conversion
analogWrite(led[0], valor1); // escribe el valor de la varibale por el pin xx
analogWrite(led[1], valor2);
analogWrite(led[2], valor3);
}
Controlar 8 LEDs desde el Arduino, un LED encendido que se mueve en forma continua de izquierda a derecha, vía una interfaz gráfica en Processing/ControlP5 para controlar el tiempo de encendido y el tiempo de apagado.
Descripción:
En este cuarto laboratorio se realizara el control de LEDs por medio de un micro controlador (ARDUINO) y mediante una interfaz gráfica donde se controlaran los tiempos de encendido y apagado.
Para esta tercera práctica el procedimiento es encender y apagar 8 LEDs mediante 8 salidas digitales del Arduino, pero ahora se manipulara los tiempos desde la interfaz gráfica.
Materiales:
Los materiales que usaremos para este segundo laboratorio son los siguientes:
8 resistencias
1 Plataforma Arduino UNO o MEGA
1 ProtoBoard
8 Leds 5mm
Diagrama:
ProtoBoard:
Esquematico:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este cuarto laboratorio.
Paso 2: Ubicar las resistencias en la ProtoBoard.
Paso 3: Ubicar los leds en la ProtoBoard.
Nota:
La pata más larga del diodo LED es el polo positivo (ánodo).
La pata más corta del diodo LED es el polo negativo (cátodo).
Paso 4: conectar el Arduino con los Leds en la ProtoBoard.
En el Ardunio ubicar donde nos dice Digital (PWM) que serían las salidas digitales en donde usaremos los pines del 2 al 9 para los Leds.
En el mismo rango encontraremos el pin GND (Tierra) que ira a la ProtoBoard donde se encuentran nuestras resistencias.
Paso 5:
Crearemos la interfaz que controlara los tiempos de encendido y apagado para los Leds, mediante la utilización de barras horizontales o sliders, en esta imagen se puede ver como quedo la interfaz después de realizar el código en processing, con esta modalidad nos ahorraríamos los potenciómetros.
Nota: Adjunto el Link donde podrán descargar la librería controlP5, también encontrara la ruta donde esta librería debería estar y lograrla importar en Proccesing.
#define maxleds 8 //creamos la variable maxleds de 8 elementos
int t1=0; // creamos una variable t1 entera
int t2=0; // creamos una variable t2 entera
int valor=0; // creamos una variable valor entera
int led[maxleds] = {2,3,4,5,6,7,8,9}; //creamos un vector para los pines a utilizar
int i; //creamos una variable entera i
void setup ()
{
Serial.begin(9600); // La comunicacion serial sera a 9600 baudios
for (int i=0;i<maxleds;i++)
pinMode(led[i],OUTPUT); // El pines del 2 al 9 seran de salida
}
void loop()
{
for (int i=0;i<=maxleds;i++)
{
if (Serial.available()>0) // si hay datos en el puerto serial entra a la condicion
{
valor = Serial.read(); // lee el valor que hay en el puerto serial
if (valor == 'O')
t1 = Serial.parseInt(); // lee y toma el siguiente valor y lo convierte a entero
if (valor == 'F')
t2 = Serial.parseInt(); // lee y toma el siguiente valor y lo convierte a entero
}
prender(led[i],t1); //llama a la funcion prender ingresando los parametros
apagar(led[i],t2); //llama a la funcion apagar ingresando los parametros
}
for (int i=maxleds;i>=0;i--)
{
if (Serial.available()>0)
{
valor = Serial.read();
if (valor == 'O')
t1 = Serial.parseInt();
if (valor == 'F')
t2 = Serial.parseInt();
}
prender(led[i],t1);
apagar(led[i],t2);
}
}
void prender(int i, int t) //funcion para enceder el led
{
digitalWrite(i, HIGH);// led esta encendido
delay(t); // tiempo encendido
}
void apagar(int i, int t)
{
digitalWrite(i, LOW);// led esta apagado
delay(t); // tiempo apagado
}
CODIGO PROCCESING:
import controlP5.*; //importar libreria controlP5
import processing.serial.*; //importar libreria serial
ControlP5 cp5; // definir la variable cp5 del tipo ControlP5
Slider slider1; // definir la variable slider1 del tipo Slider
Slider slider2; // definir la variable slider2 del tipo Slider
Serial serial; // definir la variable serial del tipo Serial
Knob perilla1;
Textlabel texto1, texto2, texto3, texto4; // definir las variables texto del tipo Textlabel
Textlabel texto5, texto6, texto7;
// configuración inicial
void setup()
{
serial = new Serial(this, Serial.list()[1],9600); // inicializamos el puerto serial a 9600 baudios
String puerto = Serial.list()[1]; //definimos la variable puerto de tipo cadena
size(750,330); // tamaño de la ventana
cp5 = new ControlP5(this); // crear el objeto ControlP5
// crear el Slider para el tiempo encendido (Vertical)
slider1 = cp5.addSlider("O",0,1000,500,80,120,30,100);
slider1.setColor(new CColor(0xFFFFFFFF,0xFF555555,0xFFBBBB20,0xFFFFFFFF,0xFFFFFFFF));
slider1.setLabelVisible(false);
// crear el Slider para el tiempo apagado (Horizontal)
slider2 = cp5.addSlider("F",0,1000,500,400,150,255,40);
slider2.setColor(new CColor(0xFFFFFFFF,0xFF555555,0xFFBBBB20,0xFFFFFFFF,0xFFFFFFFF));
slider2.setLabelVisible(false);
//crear una perilla
//perilla1 = cp5.addKnob("q",0,500,150,400,40,100);
//perilla1.setColor(new CColor (0xFF00FF00,0xFF555555,0xFF009F00,0xFFFFFFFF,0xFFFFFFFF));
// crear texto
texto1 = cp5.addTextlabel("label")
.setText("OPEN HARDWARE")
.setPosition(250,20)
.setColorValue(0xffffffFF)
.setFont(createFont("Rod",30))
;
// crear texto
texto2 = cp5.addTextlabel("label1")
.setText("TIEMPO ENCENDIDO (ms)")
.setPosition(10,220)
.setColorValue(0xffffffFF)
.setFont(createFont("Comic Sans MS",15))
;
// crear texto
texto3 = cp5.addTextlabel("label2")
.setText("TIEMPO APAGADO (ms)")
.setPosition(460,120)
.setColorValue(0xffffffFF)
.setFont(createFont("Comic Sans MS",15))
;
// texto
texto4 = new Textlabel(cp5,"Laboratorio #4 ",490,230,600,200);
texto4.setFont(createFont("MV Boli",15));
texto5 = new Textlabel(cp5,"Tecnologia Sistemas",490,250,600,200);
texto5.setFont(createFont("MV Boli",15));
texto6 = new Textlabel(cp5,"USC",490,270,600,200);
texto6.setFont(createFont("MV Boli",15));
texto7 = new Textlabel(cp5,"Johan Suarez",490,290,600,200);
texto7.setFont(createFont("MV Boli",15));
}
void draw()
{
background(58,0,255); // color de fondo de la ventana
texto4.draw(this); // introduce el texto en la ventana
texto5.draw(this);
texto6.draw(this);
texto7.draw(this);
}
void controlEvent (ControlEvent evento) // se activa el evento
{
String nombre = evento.getController().getName(); // recoje el nombre del slider y lo convierte en String
int valor = int(evento.getController().getValue()); // recoje el valor del slider y lo convierte en entero
serial.write(nombre + ":" + valor + "johan"); // envia por el puerto serial el nombre y el valor
println(nombre + ":" + valor + "johan"); // imprime por pantalla el nombre y el valor
}
Sexto Ejercicio:
Controlar un LED RGB desde el Arduino, vía PWM con una interfaz gráfica en Processing/ControlP5 para controlar el valor de cada color.
Descripción:
En este laboratorio se realizara el control de un led RGB por medio de ARDUINO, con la diferencia que se creara una interfaz gráfica para reemplazar los potenciómetros.
Para esta práctica el procedimiento es controlar la intensidad de cada uno de los colores primarios (rojo, verde y azul) para generar diferentes combinaciones de colores. Ahora la intensidad de cada color se define por medio de una interfaz gráfica.
Materiales:
Los materiales que usaremos para este segundo laboratorio son los siguientes:
3 resistencias
1 Plataforma Arduino UNO o MEGA
1 ProtoBoard
1 Led RGB
Diagrama:
ProtoBoard:
Esquematico:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este cuarto laboratorio.
Paso 2: Ubicar el Led en la ProtoBoard.
Paso 3: Ubicar las resistencias en la ProtoBoard.
Paso 4: Conectar el Arduino con el Led RGB.
Conectar las salidas PWM (3 (rojo), 5 (verde), 6 (azul)) del Arduino, a los pines del Led RGB mediante unas resistencias.
Paso 5:
Realizar la interfaz gráfica de usuario en Processing, desde ahí se podrá controlar la intensidad de cada color del Led RGB.
En esta imagen se puede ver como quedo la interfaz después de realizar el código en Processing, de manera que es mucho más fácil.
CODIGO ARDUINO:
#define MAXLED 3 //creamos la variable maxled 3 elementos
int led[MAXLED] = {3,5,6}; //creamos un vector para los pines a utilizar
int valor = 0; //creamos la variable valor de tipo entero
int i = 0; //creamos la variable valor 1 de tipo entero
void setup()
{
Serial.begin(9600); // la comunicacion serial sera a 9600 baudios
for(int i = 0; i < MAXLED ; i++)
{
pinMode(led[i], OUTPUT); // los pines del 3,5,6 seran de salida
}
}
void loop()
{
if(Serial.available() > 0) // si hay datos en el puerto serial entra a la condicion
{
valor = Serial.read(); // lee lo que hay en el puerto serial
if(valor == 'R')
i = 0;
if(valor == 'G')
i = 1;
if(valor == 'B')
i = 2;
valor = Serial.parseInt(); // lee y toma el siguiente valor convirtiandolo en entero
analogWrite(led[i], valor); // escribe el valor por el pin xx
}
}
CODIGO PROCCESING:
import controlP5.*; // importar libreria controlP5
import processing.serial.*; // importar libreria serial
ControlP5 cp5; // definir la variable cp5 del tipo ControlP5
Knob rojo, verde, azul; // definir la variable rojo,verde y azul del tipo Knob
Textlabel texto1, texto2, texto3, texto4, texto5, texto6; // definir las variables texto del tipo Textlabel
Serial serial; // definir la variable serial del tipo Serial
// configuración inicial
void setup()
{
serial = new Serial(this, Serial.list()[1],9600); // inicializamos el puerto serial a 9600 baudios
String puerto = Serial.list()[1]; //definimos la variable puerto de tipo cadena
size(620,400); // tamaño de la ventana
cp5 = new ControlP5(this); // crear el objeto ControlP5
// crear el knob para la intensidad de color rojo
rojo = cp5.addKnob("R",0,255,0,70,120,120);
rojo.setColor(new CColor(0xFFFFFFFF,0xFFFF0000,0xFF000000,0xFFFFFFFF,0xFFFFFFFF));
// crear el knob para la intensidad de color verde
verde = cp5.addKnob("G",0,255,0,260,120,120);
verde.setColor(new CColor(0xFFFFFFFF,0xFF00FF00,0xFF005F00,0xFFFFFFFF,0xFFFFFFFF));
// crear el knob para la intensidad de color azul
azul = cp5.addKnob("B",0,255,0,450,120,120);
azul.setColor(new CColor(0xFFFFFFFF,0xFF0000FF,0xFF00005f,0xFFFFFFFF,0xFFFFFFFF));
// crear texto
texto1 = cp5.addTextlabel("label")
.setText("OPEN HARDWARE")
.setPosition(150,30)
.setColorValue(0xff000000)
.setFont(createFont("Algerian",40))
;
texto2 = cp5.addTextlabel("label1")
.setText("ROJO")
.setPosition(105,250)
.setColorValue(0xff000000)
.setFont(createFont("Algerian",15))
;
texto3 = cp5.addTextlabel("label2")
.setText("VERDE")
.setPosition(290,250)
.setColorValue(0xff000000)
.setFont(createFont("Algerian",15))
;
texto4 = cp5.addTextlabel("label3")
.setText("AZUL")
.setPosition(486,250)
.setColorValue(0xff000000)
.setFont(createFont("Algerian",15))
;
// otra forma de crear texto
texto4 = new Textlabel(cp5,"Laboratorio #6",40,290,600,200);
texto4.setFont(createFont("Andalus",17));
texto4.setColorValue(0xff000000);
texto5 = new Textlabel(cp5,"Tecnologia Sistemas",40,305,600,200);
texto5.setFont(createFont("Andalus",17));
texto5.setColorValue(0xff000000);
texto6 = new Textlabel(cp5,"USC... Johan",40,320,600,200);
texto6.setFont(createFont("Andalus",17));
texto6.setColorValue(0xff000000);
}
void draw()
{
background(255,255,255); // color de fondo de la ventana
texto4.draw(this); // introduce el texto en la ventana
texto5.draw(this);
texto6.draw(this);
}
void controlEvent (ControlEvent evento) // se activa cuando ocurra un evento con los botones
{
String nombre = evento.getController().getName(); // recoje el nombre del slider y lo convierte en cadena
int valor = int(evento.getController().getValue()); // recoje el valor del slider y lo convierte en entero
serial.write(nombre + ":" + valor); // envia por el puerto serial el nombre y el valor
println(nombre + ":" + valor); // imprime por pantalla el nombre y el valor
}
Laboratorio 7: Controlar 8 LEDs desde el Arduino, a través de un IC 74HC595, definiendo mínimo 8 patrones de movimiento que son controlados desde un Potenciómetro.
Descripción:
En este laboratorio se realizara el control de 8 Leds por medio de un integrado IC 74HC595, el cual recibe los datos en forma serial y su salida es en forma paralela (8 bits).
Para esta práctica el procedimiento es crear 8 secuencias diferentes y por medio de un potenciometro ir graduando la secuencia. Gracias a la comunicación serial del Arduino, este se puede comunicar de manera serial con el integrado por medio de 3 pines los cuales son:
pinLatch = 2;
pinReloj = 3;
pinDato = 4;
El 74HC595: tiene 8 salidas marcadas Qa-Qc (o Q0-Q7), no puede leer datos de estos pines, sólo se pueden utilizar como salidas.
Las siguientes conexiones son necesarias:
GND (pin 8) a masa
Vcc (pin 16) a 5V
OE (pin 13) a masa
MR (pin 10) a 5V
Esta configuración hace que todas las salidas estén activas y disponibles todo el tiempo,
DS (pin 14) al pin digital 11 (cable azul)
SH_CP (pin 11) al pin digital 12 (cable amarillo)
ST_CP (pin 12) al pin digital 8 (cable verde)
Desde ahora serán conocidos como dataPin (DS), clockPin (SH_CP) y latchPin (ST_CP) respectively.
Materiales:
Los materiales que usaremos para este séptimo laboratorio son los siguientes:
8 — resistencias
8 — Leds
1 — Potenciómetro 10k
1 — plataforma Arduino Uno o MEGA
1 — Integrado IC 74HC595
1 — Protoboard
Diagrama:
ProtoBoard:
Esquemático:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este séptimo laboratorio.
Paso 2: Ubicar las resistencias en la ProtoBoard.
Paso 3: Ubicar los Leds en la ProtoBoard.
Paso 4: Ubicar el Integrado IC 74HC595 en la ProtoBoard con sus pines de alimentación.
Paso 5: Ubicar el Potenciómetro de 10k.
Paso 6: Conectar el Arduino al integrado, por medio de sus salidas digitales. Las salidas digitales del Arduino a utilizar, son los pines del 2 al 4.
Desde el integrado a Arduino.
DS (pin 14) al pin digital 2
SH_CP (pin 11) al pin digital 3
ST_CP (pin 12) al pin digital 4
Y Desde ahora serán conocidos como dataPin (DS), clockPin (SH_CP) y latchPin (ST_CP) respectively.
CODIGO ARDUINO:
#define PIN 3 //creamos la variable PIN de 3 elementos
#define Pot A0 //creamos la variable pot con el pin A0
const int Latch = 2; // Este pin sets baja cuando quiero que el 595 se escuche
const int Clock = 3; // Este pin es utilizado por shiftout para alternar
const int Data = 4; // Este pin se utiliza para pasar al siguiente bit
int led[PIN] = {2,3,4}; //creamos un vector para los pines a utilizar
int Serie1[17]={ 0,1,3,7,15,31,63,127,255,127,63,31,15,7,3,1,0 };
int Serie2[7]= { 129,66,36,24,36,66,129 };
int Serie3[11]={ 7,14,28,56,112,224,112,56,28,14,7 };
int Serie4[6]= { 24,129,36,24,129,21 };
int Serie5[8]= { 129,130,132,136,144,160,192,128 };
int Serie6[7]= { 24,20,18,17,18,20,24 };
int Serie7[4]= { 192,48,12,3 };
int Serie8[8]= { 80,10,255,255,0,255,10,80 };
// Solo se ejecuta una vez, al iniciar o resetear el Arduino
void setup() {
for (int i=0; i<PIN; i++){
pinMode(led[i], OUTPUT);
}
pinMode(Pot, INPUT);
}
// se ejecuta siempre como un ciclo
void loop()
{
int Pos = analogRead(Pot); // lee el valor del potenciometro
Pos = map(Pos, 0, 1023, 0,7); // hace un mapeo o conversion
Casos(Pos); // llama a la funcion casos
}
void Casos(int Valor) //funcion para enceder el led
{
switch(Valor)
{
case 0: //hacer algo cuando sea igual a 0
for(int j=0;j<17;j++)
{
On(Serie1[j]);
}
break;
case 1: //hacer algo cuando sea igual a 1
for(int j=0;j<7;j++)
{
On(Serie2[j]);
}
break;
case 2: //hacer algo cuando sea igual a 2
for(int j=0;j<11;j++)
{
On(Serie3[j]);
}
break;
case 3: //hacer algo cuando sea igual a 3
for(int j=0;j<6;j++)
{
On(Serie4[j]);
}
break;
case 4: //hacer algo cuando sea igual a 4
for(int j=0;j<8;j++)
{
On(Serie5[j]);
}
break;
case 5: //hacer algo cuando sea igual a 5
for(int j=0;j<7;j++)
{
On(Serie6[j]);
}
break;
case 6: //hacer algo cuando sea igual a 6
for(int j=0;j<4;j++)
{
On(Serie7[j]);
}
break;
case 7: //hacer algo cuando sea igual a 7
for(int j=0;j<8;j++)
{
On(Serie8[j]);
}
break;
}
}
// Uso de la orden interna shiftout función
void On(int Valor)
{
digitalWrite(Latch, LOW); // señal al 595 para escuchar los datos
shiftOut(Data, Clock, MSBFIRST, Valor); // Señal de la 595 que esta hecho
digitalWrite(Latch, HIGH); // enviar datos serial
delay(100); //Pausa el programa por un tiempo determinado (en milisegundos) especificado por el parámetro. Hay 1000 milisegundos en un segundo
}
Laboratorio 8: Controlar 8 LEDs desde el Arduino, a través de un IC 74HC595, vía una interfaz gráfica en Processing/ControlP5 para controlar individualmente que LED está encendido o apagado.
Descripción:
En este laboratorio se realizara el control de 8 Leds por medio de un integrado IC 74HC595, lo cual tendremos que realizar una interfaz gráfica para controlar los Leds individualmente tanto para encendido y apagado.
Materiales:
Los materiales que usaremos para este octavo laboratorio son los siguientes:
8 — resistencias
8 — Leds
1 — plataforma Arduino Uno o MEGA
1 — Integrado IC 74HC595
1 — Protoboard
Diagrama:
ProtoBoard:
Esquemático:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este octavo laboratorio.
Paso 2: Ubicar las resistencias en la ProtoBoard.
Paso 3: Ubicar los Leds en la ProtoBoard.
Paso 4: Ubicar el Integrado IC 74HC595 en la ProtoBoard con sus pines de alimentación.
Paso 5: Conectar el Arduino al integrado, por medio de sus salidas digitales. Las salidas digitales del Arduino a utilizar, son los pines del 2 al 4.
CODIGO ARDUINO:
#define pines 3 //creamos la variable maxleds de 8 elementos
const int pinLatch = 2; // Este pin se sets baja cuando quiero que el 595 para escuchar
const int pinReloj = 3; // Este pin es utilizado por shiftout para alternar decir que hay otro granito de arena para cambiar
const int pinDato = 4; // Este pin se utiliza para pasar al siguiente bit
int led[pines] = {2,3,4}; //creamos un vector para los pines a utilizar
int valor=0;
int i=0;
// Solo se ejecuta una vez, al iniciar o resetear el Arduino
void setup ()
{
Serial.begin(9600); // la comunicacion serial sera a 9600 baudios
for (int i=0;i<pines;i++)
pinMode(led[i],OUTPUT); // El pines del 2 al 4 seran de salida
}
// se ejecuta siempre como un ciclo
void loop()
{
if(Serial.available() > 0) // si hay datos en el puerto serial entra a la condicion
{
valor = Serial.read(); // lee lo que hay en el puerto serial
activacion(valor);
//Serial.println(valor);
}
}
void activacion(int i)
{
digitalWrite (pinLatch, LOW); // Signal to the 595 to listen for data
shiftOut (pinDato, pinReloj, MSBFIRST, valor); // Signal to the 595 that I'm done sending
digitalWrite (pinLatch, HIGH); // sendSerialData1
delay(50);
}
CODIGO PROCCESING:
import controlP5.*; // utilizar la libreria controlp5
import processing.serial.*; // utilizar la liberia processing.serial
ControlP5 cp5; // definir la variable cp5 del tipo ControlP5
Toggle l1, l2, l3, l4, l5, l6, l7, l8; // definir la variable rojo,verde y azul del tipo Knob
Textlabel texto1, texto4, texto5; // definir las variables texto del tipo Textlabel
Serial serial; // definir la variable serial del tipo Serial
// como deseamos controlar 8 LEDs, usamos un arreglo
int[] led = new int[] {0, 0, 0, 0, 0, 0, 0, 0};
// configuración inicial
void setup()
{
serial = new Serial(this, Serial.list()[1], 9600); // inicializamos el puerto serial a 9600 baudios
String puerto = Serial.list()[1]; //definimos la variable puerto de tipo cadena
size(630, 400); // tamaño de la ventana
cp5 = new ControlP5(this); // crear el objeto ControlP5
// crear un botón para encender/apagar cada LED
for (int i=0; i<led.length; i++)
cp5.addToggle("LED"+i, 50+i*70, 220, 40, 40);
// texto
texto1 = cp5.addTextlabel("label")
.setText("OPEN HARDWARE")
.setPosition(90, 20)
.setColorValue(0xffffffFF)
.setFont(createFont("Algerian", 55))
;
// texto
texto4 = new Textlabel(cp5, "Laboratorio #8", 220, 295, 600, 200);
texto4.setFont(createFont("Andalus", 25));
texto5 = new Textlabel(cp5, "Johan Suarez", 40, 375, 600, 200);
texto5.setFont(createFont("Andalus", 15));
}
void draw()
{
background(90, 138, 255); // fondo de la ventana
texto4.draw(this); // introduce el texto en la ventana
texto5.draw(this);
for (int i=0; i<led.length; i++) {
// definir el color de relleno, 0=apagado, 1=encendido
fill(led[i] == 0 ? 0x000000 : 0xFFFFFFFF);
// dibujar un circulo con ese color
ellipse(70+i*70, 140, 80, 80);
}
}
void controlEvent (ControlEvent evento) // se activa cuando ocurra un evento con los botones
{
String nombre = evento.getController().getName(); // recoje el nombre del slider y lo convierte en cadena
int valor = int(evento.getController().getValue()); // recoje el valor del slider y lo convierte en entero
int resultado = 0;
//serial.write(nombre + ":" + valor); // envia por el puerto serial el nombre y el valor
//println(nombre + ":" + valor); // imprime por pantalla el nombre y el valor
for (int i=0; i<led.length; i++) {
if (nombre.equals("LED"+i)) {
led[i] = valor;
// println("led[" + i + "]: " + nombre + " = "+valor);
}
resultado |= (led[i] << i);
}
serial.write(resultado);
println(resultado);
}
Controlar desde el Arduino, un Display LED de 7-Segmentos, a través de un IC 74HC595, para mostrar un número de 0 a 9, dependiente de la posición del Potenciómetro.
Descripción:
En este laboratorio se realizara el control de un Display 7 segmentos por medio de un integrado IC 74HC595, el cual recibe los datos en forma serial y su salida es en forma paralela (8 bits).
Para esta práctica, el procedimiento es crear una tabla de secuencias que contenga cada uno de los números del 0 al 9 y por medio de un potenciómetro ir graduando el número a mostrar.
Materiales:
Los materiales que usaremos para este noveno laboratorio son los siguientes:
2 — resistencias
1 — Display LED de 7-Segmentos Cátodo común
1 — plataforma Arduino Uno o MEGA
1 — Integrado IC 74HC595
1 — Protoboard
1 — Potenciómetro.
Diagrama:
ProtoBoard:
Esquematico:
Imágenes del proceso de montaje:
Paso 1: Disponer de todos los materiales necesarios para este noveno laboratorio.
Paso 2: Ubicar las resistencias y el Integrado IC 74HC595 en la ProtoBoard con sus pines de alimentación.
Paso 3: Ubicar el Potenciómetro en el lugar que corresponde con sus pines de alimentación ya ubicados en la ProtoBoard.
Paso 4:
Conectar el Arduino al integrado, por medio de sus salidas digitales. Las salidas digitales del Arduino a utilizar, son los pines del 7 al 9.
const int Latch = 8;
const int Clock = 9;
const int Data = 7;
Conectar el Potenciometro de 10k a la placa Arduino, el pin del medio del Potenciometro se conectan al pin analogo A0.
Conectar los pines del integrado (Q0,Q1,Q2,Q3,Q4…..) A los pines del display respectivamente (A,B,C,D,E…..)
Paso 5: Códigos de números y letras.
CODIGO ARDUINO:
// Se definen la cantidad de pines que vamos a usar como PIN
// y la entrada analoga A0 como la que se va a usar por el
// potenciómetro
#define PIN 3
#define Pot A0
// Se le dan nombres a los pines (7-9) del arduino
// que van a ser usados por el integrado respectivamente
// además el pin SH_CP osea Clock debe ser PWM(~)
const int Latch = 8;
const int Clock = 9;
const int Data = 7;
int led[PIN] = {
7,8,9};
// El valor de cada uno de los numeros que voy
// a mostrar en mi Display
int Numeros[10]={63,6,91,79,102,109,125,7,127,111};
// Ciclo para activar los ocho pines como salida
// y el pin A0 como entrada
void setup() {
for (int i=0; i<PIN; i++){
pinMode(led[i], OUTPUT);
}
pinMode(Pot, INPUT);
}
// Recibe la info de la posición del potenciómetro
void loop()
{
int Pos = analogRead(Pot);
Pos = map(Pos, 0, 1023, 0,10);
Casos(Pos);
}
// Según la posición del potenciómetro escoge un caso
// osea un numero
void Casos(int Valor)
{
switch(Valor)
{
case 0:
On(Numeros[0]);
break;
case 1:
On(Numeros[1]);
break;
case 2:
On(Numeros[2]);
break;
case 3:
On(Numeros[3]);
break;
case 4:
On(Numeros[4]);
break;
case 5:
On(Numeros[5]);
break;
case 6:
On(Numeros[6]);
break;
case 7:
On(Numeros[7]);
break;
case 8:
On(Numeros[8]);
break;
case 9:
On(Numeros[9]);
break;
}
}
// Función para enviar los datos al Integrado IC 74HC595
void On(int Valor)
{
digitalWrite(Latch, LOW);
shiftOut(Data, Clock, MSBFIRST, Valor);
digitalWrite(Latch, HIGH);
delay(8);
}
CODIGO ARDUINO USANDO LETRAS:
// Se definen la cantidad de pines que vamos a usar como PIN
// y la entrada analoga A0 como la que se va a usar por el
// potenciómetro
#define PIN 3
#define Pot A0
// Se le dan nombres a los pines (7-9) del arduino
// que van a ser usados por el integrado respectivamente
// además el pin SH_CP osea Clock debe ser PWM(~)
const int Latch = 8;
const int Clock = 9;
const int Data = 7;
int led[PIN] = {
7,8,9};
// El valor de cada uno de los numeros que voy
// a mostrar en mi Display
int Numeros[10]={30,118,63,119,84,128,62,109,57,128};
// Ciclo para activar los ocho pines como salida
// y el pin A0 como entrada
void setup() {
for (int i=0; i<PIN; i++){
pinMode(led[i], OUTPUT);
}
pinMode(Pot, INPUT);
}
// Recibe la info de la posición del potenciómetro
void loop()
{
int Pos = analogRead(Pot);
Pos = map(Pos, 0, 1023, 0,10);
Casos(Pos);
}
// Según la posición del potenciómetro escoge un caso
// osea un numero
void Casos(int Valor)
{
switch(Valor)
{
case 0:
On(Numeros[0]);
break;
case 1:
On(Numeros[1]);
break;
case 2:
On(Numeros[2]);
break;
case 3:
On(Numeros[3]);
break;
case 4:
On(Numeros[4]);
break;
case 5:
On(Numeros[5]);
break;
case 6:
On(Numeros[6]);
break;
case 7:
On(Numeros[7]);
break;
case 8:
On(Numeros[8]);
break;
case 9:
On(Numeros[9]);
break;
}
}
// Función para enviar los datos al Integrado IC 74HC595
void On(int Valor)
{
digitalWrite(Latch, LOW);
shiftOut(Data, Clock, MSBFIRST, Valor);
digitalWrite(Latch, HIGH);
delay(8);
}
Sistemas Embebidos 