programación de sistemas embebidos

sábado, 30 de mayo de 2015

laboratorio #11

enviar desde una pagina web un mensaje a una matriz LED 8x8 que se desplaza de izquierda a derecha atraves de un IC MAX7219

materiales a utilizar

placa Arduino uno o Arduino mega
matriz LED 8X8
cables varios

montaje

codigo arduino

#include "LedControl.h"
pin 12 = DataIn:din
pin 11 = CLK
pin 10 = : cs

//laboratorio #11 : Enviar desde una página web un mensaje a una matriz LED 8x8 (desplazándose de izquierda a derecha) a través de IC MAX7219.

*/
LedControl lc = LedControl(12,11,10);

//ASCII TABLE

byte chars[129][8] = {
{0,0,0,0,0,0,0,0}, // 0
{0,0,0,0,0,0,0,0}, // 1
{0,0,0,0,0,0,0,0}, // 2
{0,0,0,0,0,0,0,0}, // 3
{0,0,0,0,0,0,0,0}, // 4
{0,0,0,0,0,0,0,0}, // 5
{0,0,0,0,0,0,0,0}, // 6
{0,0,0,0,0,0,0,0}, // 7
{0,0,0,0,0,0,0,0}, // 8
{0,0,0,0,0,0,0,0}, // 9
{0,0,0,0,0,0,0,0}, // 10
{0,0,0,0,0,0,0,0}, // 11
{0,0,0,0,0,0,0,0}, // 12
{0,0,0,0,0,0,0,0}, // 13
{0,0,0,0,0,0,0,0}, // 14
{0,0,0,0,0,0,0,0}, // 15
{0,0,0,0,0,0,0,0}, // 16
{0,0,0,0,0,0,0,0}, // 17
{0,0,0,0,0,0,0,0}, // 18
{0,0,0,0,0,0,0,0}, // 19
{0,0,0,0,0,0,0,0}, // 20
{0,0,0,0,0,0,0,0}, // 21
{0,0,0,0,0,0,0,0}, // 22
{0,0,0,0,0,0,0,0}, // 23
{0,0,0,0,0,0,0,0}, // 24
{0,0,0,0,0,0,0,0}, // 25
{0,0,0,0,0,0,0,0}, // 26
{0,0,0,0,0,0,0,0}, // 27
{0,0,0,0,0,0,0,0}, // 28
{0,0,0,0,0,0,0,0}, // 29
{0,0,0,0,0,0,0,0}, // 30
{0,0,0,0,0,0,0,0}, // 31
{0,0,0,0,0,0,0,0}, // 32
{0,0,0,0,0,0,0,0}, // 33
{0,0,0,0,0,0,0,0}, // 34
{0,0,0,0,0,0,0,0}, // 35
{0,0,0,0,0,0,0,0}, // 36
{0,0,0,0,0,0,0,0}, // 37
{0,0,0,0,0,0,0,0}, // 38
{0,0,0,0,0,0,0,0}, // 39
{0,0,0,0,0,0,0,0}, // 40
{0,0,0,0,0,0,0,0}, // 41
{0,0,0,0,0,0,0,0}, // 42
{0,0,0,0,0,0,0,0}, // 43
{0,0,0,0,0,0,0,0}, // 44
{0,0,0,0,0,0,0,0}, // 45
{0,0,0,0,0,0,0,0}, // 46
{0,0,0,0,0,0,0,0}, // 47
{0,0,0,0,0,0,0,0}, // 48
{0,0,0,0,0,0,0,0}, // 49
{0,0,0,0,0,0,0,0}, // 50
{0,0,0,0,0,0,0,0}, // 51
{0,0,0,0,0,0,0,0}, // 52
{0,0,0,0,0,0,0,0}, // 53
{0,0,0,0,0,0,0,0}, // 54
{0,0,0,0,0,0,0,0}, // 55
{0,0,0,0,0,0,0,0}, // 56
{0,0,0,0,0,0,0,0}, // 57
{0,0,0,0,0,0,0,0}, // 58
{0,0,0,0,0,0,0,0}, // 59
{0,0,0,0,0,0,0,0}, // 60
{0,0,0,0,0,0,0,0}, // 61
{0,0,0,0,0,0,0,0}, // 62
{0,0,0,0,0,0,0,0}, // 63
{0,0,0,0,0,0,0,0}, // 64
{B11110110,B11111111,B00001001,B00001001,B00001001,B00001001,B11111111,B11110110}, // 65A
{B11111111,B11111111,B10001001,B10001001,B10001001,B10001001,B11111111,B01110110}, // 66B
{B11111111,B11111111,B11100111,B11000011,B11000011,B11000011,B11000011,B11000011}, // 67C
{B11111111,B11111111,B11000011,B11000011,B11000011,B11000011,B11111111,B01111110}, // 68D
{B01111110,B11111111,B11011011,B11011011,B11011011,B11000011,B11000011,B00000000},//E
{B11111110,B11111111,B00110011,B00110011,B00110011,B00110011,B00110011,B00000000},//F
{B11111110,B11111111,B10000011,B10011011,B10011011,B10011011,B10011011,B11110011},//G
{B11111111,B11111111,B00011000,B00011000,B00011000,B00011000,B11111111,B11111111},//H
{B11000011,B11000011,B11000011,B11111111,B11111111,B11000011,B11000011,B11000011},//I
{B11000011,B11000011,B11000011,B11111111,B11111111,B00000011,B00000011,B00000011},//J
{B11111111,B11111111,B00011000,B00011000,B00111100,B01100110,B11000011,B10000001},//K
{B11111111,B11111111,B11100000,B11000000,B11000000,B11000000,B11000000,B00000000},//L
{B11111111,B11111111,B00000110,B00011100,B00011100,B00000110,B11111111,B11111111},//M
{B11111111,B11111111,B00000110,B00001100,B00011000,B00110000,B11111111,B11111111},//N
{B01111110,B11111111,B11000011,B10000001,B10000001,B11000011,B11111111,B01111110},//O
{B11111110,B11111111,B00011111,B00010001,B00010001,B00011111,B00011111,B00000000},//P
{B00111110,B01111111,B01000001,B01000001,B01010001,B01100001,B01111111,B10111110},//Q
{B11111110,B11111111,B00011001,B00011001,B00011001,B00111001,B11011111,B10001110},//R
{B11001110,B11011111,B11011011,B11011011,B11011011,B11011011,B11111011,B01110011}, // 83S
{B00000011,B00000011,B00000011,B11111111,B11111111,B00000011,B00000011,B00000011}, // 84T
{B11111111,B11111111,B11000000,B11000000,B11000000,B11000000,B11111111,B11111111}, // 85U
{B00011111,B00111100,B01110000,B11100000,B11100000,B01110000,B00111100,B00011111},//V
{B00111110,B01111000,B11110000,B00111000,B00111000,B11110000,B01111000,B00111110},//W
{B10000001,B11000011,B01100110,B00011000,B00011000,B01100110,B11000011,B10000001},//X
{B00000001,B00000111,B00001100,B11111000,B11111000,B00001100,B00000111,B00000001},//Y
{B11000001,B11100001,B11110001,B10111001,B10011101,B10001111,B10000111,B10000011},//Z
{0,0,0,0,0,0,0,0}, // 91
{0,0,0,0,0,0,0,0}, // 92
{0,0,0,0,0,0,0,0}, // 93
{0,0,0,0,0,0,0,0}, // 94
{0,0,0,0,0,0,0,0}, // 95
{0,0,0,0,0,0,0,0}, // 96
{B11110110,B11111111,B00001001,B00001001,B00001001,B00001001,B11111111,B11110110}, // 65A
{B11111111,B11111111,B10001001,B10001001,B10001001,B10001001,B11111111,B01110110}, // 66B
{B11111111,B11111111,B11100111,B11000011,B11000011,B11000011,B11000011,B11000011}, // 67C
{B11111111,B11111111,B11000011,B11000011,B11000011,B11000011,B11111111,B01111110}, // 68D
{B01111110,B11111111,B11011011,B11011011,B11011011,B11000011,B11000011,B00000000},//E
{B11111110,B11111111,B00110011,B00110011,B00110011,B00110011,B00110011,B00000000},//F
{B11111110,B11111111,B10000011,B10011011,B10011011,B10011011,B10011011,B11110011},//G
{B11111111,B11111111,B00011000,B00011000,B00011000,B00011000,B11111111,B11111111},//H
{B11000011,B11000011,B11000011,B11111111,B11111111,B11000011,B11000011,B11000011},//I
{B11000011,B11000011,B11000011,B11111111,B11111111,B00000011,B00000011,B00000011},//J
{B11111111,B11111111,B00011000,B00011000,B00111100,B01100110,B11000011,B10000001},//K
{B11111111,B11111111,B11100000,B11000000,B11000000,B11000000,B11000000,B00000000},//L
{B11111111,B11111111,B00000110,B00011100,B00011100,B00000110,B11111111,B11111111},//M
{B11111111,B11111111,B00000110,B00001100,B00011000,B00110000,B11111111,B11111111},//N
{B01111110,B11111111,B11000011,B10000001,B10000001,B11000011,B11111111,B01111110},//O
{B11111110,B11111111,B00011111,B00010001,B00010001,B00011111,B00011111,B00000000},//P
{B00111110,B01111111,B01000001,B01000001,B01010001,B01100001,B01111111,B10111110},//Q
{B11111110,B11111111,B00011001,B00011001,B00011001,B00111001,B11011111,B10001110},//R
{B11001110,B11011111,B11011011,B11011011,B11011011,B11011011,B11111011,B01110011}, // 83S
{B00000011,B00000011,B00000011,B11111111,B11111111,B00000011,B00000011,B00000011}, // 84T
{B11111111,B11111111,B11000000,B11000000,B11000000,B11000000,B11111111,B11111111}, // 85U
{B00011111,B00111100,B01110000,B11100000,B11100000,B01110000,B00111100,B00011111},//V
{B00111110,B01111000,B11110000,B00111000,B00111000,B11110000,B01111000,B00111110},//W
{B10000001,B11000011,B01100110,B00011000,B00011000,B01100110,B11000011,B10000001},//X
{B00000001,B00000111,B00001100,B11111000,B11111000,B00001100,B00000111,B00000001},//Y
{B11000001,B11100001,B11110001,B10111001,B10011101,B10001111,B10000111,B10000011},//Z
{0,0,0,0,0,0,0,0}, // 123
{0,0,0,0,0,0,0,0}, // 124
{0,0,0,0,0,0,0,0}, // 125
{0,0,0,0,0,0,0,0}, // 126
{0,0,0,0,0,0,0,0}, // 127
{0,0,0,0,0,0,0,0} // 128
};

/* siempre esperamos un poco entre las actualizaciones de la pantalla */

void setup() {
/*
El MAX72XX está en modo de ahorro de energía en el arranque,
tenemos que hacer una llamada de atención
*/

lc.shutdown(0,false);
/* Set the brightness to a medium values */
lc.setIntensity(0,8);
/* and clear the display */
lc.clearDisplay(0);

Serial.begin(9600);

}

/*
Este método mostrará los caracteres para la
palabra "Arduino" uno tras otro en la matriz.
(se necesitan al menos leds 5x7 para ver todo el caracteres)
*/
void writeChar(char chLetter, int nuDelayTime) {

for (int i=0; i<8; i++){
lc.setRow(0,i,chars[chLetter][i]);
}

delay(nuDelayTime);

}

void loop() {

Serial.flush();

if (Serial.available() > 0) {

char chLetter = Serial.read();

writeChar(chLetter,700);

}

}

video del laboratorio

laboratorio #10

En este laboratorio se muestra un mensaje de izquierda a derecha en una matriz de LEDs de 8x8 atraves de un ICMAX7219 enviado desde un Arduino.

Elementos utilizados

placa Arduino uno o mega
matriz de leds de 8x8
cables varios

diagrama en fritzing

codigo Arduino

#include "LedControl.h"
String texto="universidad santiago de cali:";

LedControl lc=LedControl(12,11,10,1);

/* we always wait a bit between updates of the display */
unsigned long delaytime=100;

void setup() {
Serial.begin(9600);
/*
The MAX72XX is in power-saving mode on startup,
we have to do a wakeup call
*/
lc.shutdown(0,false);
/* Set the brightness to a medium values */
lc.setIntensity(0,8);
/* and clear the display */
lc.clearDisplay(0);
}
char abcMAY[36]={'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z','1','2', '3', '4', '5', '6', '7', '8', '9', '0'};
char abcMIN[36]={'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','1','2', '3', '4', '5', '6', '7', '8', '9', '0'};
byte letras[36][5]= { {B11111110,B00010001,B00010001,B00010001,B11111110},//A
{0xFF, 0x89, 0x89, 0x89, 0x76},//B
{B01111110,B10000001,B10000001,B10000001,B01000110},//C
{0xff, 0x81, 0x81, 0x81, 0x7e},//D
{0x7e, 0x89, 0x89, 0x89, 0x89},//E
{0xff, 0x09, 0x09, 0x09, 0x01},//F
{0x7e, 0x89, 0x89, 0x89, 0xf2},//G
{0xFF, 0x18, 0x18, 0x18,0xff},//H
{B00000000,B10000100,B11111101,B10000000,B00000000},//I
{0x71, 0x81, 0x7f, 0x01, 0x01},//J
{0xff, 0x10, 0x2c, 0x42, 0x81},//K
{0x7f, 0xc0, 0x80,0x80, 0x80},//L
{0xff, 0x06, 0x0c, 0x06, 0xff},//M
{B11111111,B00000100,B00001000,B00010000,B11111111}, //N
{B01111110,B10000001,B10000001,B10000001,B01111110},//O
{0xff, 0x09, 0x09, 0x09, 0x06},//P
{0xbe, 0x41,0xA1, 0x81, 0x7e},//Q
{B11111111,B00010001,B00110001,B01010001,B10001110},//R
{0x86, 0x89, 0x89, 0x89, 0x71},//S
{0x01, 0x01, 0xff, 0x01, 0x01},//T
{B01111111,B11000000,B11000000,B11000000,B01111111},//U
{0x3f, 0x40, 0x80, 0x40, 0x3f},//V
{0x7f, 0x80, 0x70, 0x80, 0x7f},//W
{0xe3, 0x14, 0x08, 0x14, 0xe3},//X
{0x03, 0x04, 0xf8, 0x04, 0x03},//Y
{0xe1, 0x91, 0x89, 0x85, 0x83 }//Z

,{0x00, 0x82, 0xff, 0x80,0x00},//1
{0xc2, 0xa1, 0x91, 0x89, 0x86},//2
{0x81,0x81,0x85,0x8b,0x71},//3
{0x18,0x14, 0x12, 0xff, 0x00},//4
{0x8f, 0x89, 0x89, 0x89, 0x71},//5
{0x7c, 0x8a, 0x89, 0x89, 0x70},//6
{0x01, 0xf1, 0x09,0x05, 0x03},//7
{0x76, 0x89, 0x89, 0x89, 0x76},//8
{0x06, 0x89, 0x89, 0x89, 0x7e },//9
{B01111110,B11100001,B10011001,B10000111,B01111110},//O
};
/*
This method will display the characters for the
word "Arduino" one after the other on the matrix.
(you need at least 5x7 leds to see the whole chars)
*/
void writeArduinoOnMatrix(String mensajea) {
/* here is the data for the characters */

for(int j=0;j<mensajea.length();j++){
for(int k=0;k<36;k++){
if(mensajea.charAt(j)==abcMAY[k] || mensajea.charAt(j)==abcMIN[k]){
palabras(letras[k]);
}
}
}

}
void palabras(byte listd[]){
for(int j=7;j>-4;j--){

for(int i=4; i> -1; i--){
lc.setRow(0,j+i,listd[i]);
}
delay(delaytime);
for(int o=0; o<8 ; o++){
lc.setRow(0,o,0);
}
}
}

void loop() {
writeArduinoOnMatrix(texto);

}

void serialEvent(){
while(Serial.available()){
texto= Serial.readString();
}
}

video del laboratorio

jueves, 28 de mayo de 2015

laboratorio #8

En este laboratorio se manipulara en la pantalla de un computador un objeto gráfico usando processing leyendo los datos en Arduino mega desde un joystick shield

Lista de componentes

placa arduino uno o mega
cables varios
joystick

Montaje

montaje en protoboard

diagrama en fritzing

codigo arduino

//laboratorio 8
int pinarr=4; //pines a utilizar
int pinaba=5;
int pinizq=6;
int pinder=3;
int po=A0;
int pa=A1;

void setup()
{
//se inicia la comunicacion serial
//y se asignan el modo de los pines
Serial.begin(9600);
pinMode(pinarr, INPUT);
pinMode(pinaba, INPUT);
pinMode(pinizq, INPUT);
pinMode(pinder, INPUT);
pinMode(po, INPUT);
pinMode(pa, INPUT);

}
int x;
int y;
void loop()
{
x=analogRead(po);
y=analogRead(pa);

if (y>1022){
Serial.println("arriba");

}
if (y<1){
Serial.println("abajo");

}
if (x>1022){
Serial.println("der");

}
if (x<1){
Serial.println("izq");

}
delay(200);

}

codigo processing

import controlP5.*;
import processing.serial.*;

PImage img;
int iW2, iH2;
int posX, posY;
int velocity, angle;
Serial serial;
String val;
void setup() {
serial = new Serial(this, Serial.list()[0], 9600);
// tamaño de la ventana
size(800, 600);
// carga la imagen en la variable
img = loadImage("spaceship.gif");
iW2 = img.width/2;
iH2 = img.height/2;
posX = (width/2)-iW2;
posY = (height/2)-iH2;
velocity = -5;
angle = 0;
}

void draw() {
// limpia la ventana
background(0);
posX += velocity * sin(radians(angle));
if (posX-iW2 < 0) posX = width;
if (posX-iW2 > width) posX = iW2;
posY += velocity * cos(radians(angle));
if (posY-iH2 < 0) posY = height;
if (posY-iH2 > height) posY = iH2;
// dibuja la imagen
pushMatrix();
translate(posX-iW2, posY-iH2);
rotate(radians(-angle));
image(img, -iW2, -iH2);
popMatrix();
Cambio();
}
/*
void keyPressed() {
if (key == CODED) {
if (keyCode == UP)
velocity -= 5;
if (keyCode == DOWN)
velocity += 5;
if (keyCode == LEFT)
angle += 5;
if (keyCode == RIGHT)
angle -= 5;
}
}*/

void Cambio(){
if ( serial.available() > 0)
{ // If data is available,
val = serial.readString()+""; // read it and store it in val

}

println(val); //print it out in the console
if(val==null){val="0";}
if(val.indexOf("arriba")>=0){
velocity -= 5;
val="";
}
if(val.indexOf("abajo")>=0){
velocity += 5;
val="";
}
if(val.indexOf("izq")>=0){
angle += 5;
val="";
}
if(val.indexOf("der")>=0){
angle -= 5;
val="";
}

}

vídeo del laboratorio

jueves, 26 de marzo de 2015

laboratorio 0

laboratorio 0

en este laboratorio se controla el tiempo de encendido y apagado de un led desde una placa arduino y por medio de un potenciometro se controla este tiempo.

materiales

placa arduino mega o arduino uno + pc con ide arduino+cable de comunicacion
1 led
1 resistencia de 1kohm
1 potenciometro de 10kohm
jumper varios

montaje

esquema en fritzing

montaje en fritzing

codigo arduino

#define LED 2 //led conectado al pin digital 2
#define POT A0 //potenciometro como entrada al A0

void setup() {
pinMode(LED, OUTPUT);
pinMode(POT, INPUT);
}

void loop() {

int tiempo = analogRead(POT);//lectura del potenciometro

digitalWrite(LED, HIGH);//led encendido
delay(tiempo); //tiempo de encendido
digitalWrite(LED, LOW); //led apagado
delay(tiempo); //tiempo de apagado

}

video

miércoles, 25 de marzo de 2015

laboratorio 7

laboratorio 7
consiste en controlar un display de 7 segmentos de catodo común desde arduino por medio de un IC 74HC595 mostrando los números del 0 al 9 dependiendo la posición de un potencio-metro.

materiales

placa arduino mega + cable de comunicacion +pc con ide arduino
display de 7 segmentos catodo comun
2 resistencias de 1kohm
1 potenciometro de 10kohm
jumper varios
protoboard

montaje en protoboard fritzing

esquematico en fritzing

montaje del circuito

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 = 3;

const int Clock = 4;

const int Data = 2;

int led[PIN] = {

2,3,4};

// 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);

}

video

laboratorio 6

laboratorio 6
en este laboratorio se controlan 8 LEDs desde arduino atraves de un IC 74Hc595 definiendo mínimo 8 patrones de movimiento que son controlados desde una interfaz gráfica en processing/controlIp5.

materiales

placa arduino +cable de comunicacion +pc con ide arduino y processing
8 LEDs + 8 resistencias 1kohm + protoboard
jumper varios
1 Ic 74HC595

diagrama en protoboard

diagrama en fritzing

montaje de componentes

codigo arduino

// pin que envia los datos al 74HC595
int data_pin = 9;
// pin que conecta el latch
int latch_pin = 10;
// pin que conecta el reloj
int clock_pin = 11;

// Guardamos el valor lo que recibimos via serial
int valor, val;
char letr;

//primera secuencia : arreglo de dos en dos.
int ledS1[4] = {3, 12, 48, 192};

//segunda secuencia : arreglo de uno en uno
int ledS2[8] = {1, 2, 4, 8, 16, 32, 64, 128};

//segunda secuencia : arreglo de uno en uno
int ledS3[8] = {1, 4, 2, 8, 16, 64, 32, 128};

//segunda secuencia : arreglo de uno en uno
int ledS4[2] = {255, 0};

//segunda secuencia : arreglo de un leds de los extremos al medio
int ledS5[12] = {1,128,2,64,4,32,8,16,4,32,2,64};

//tercera secuencia
int ledS6[22] = {1,4,2,8,4,16,8,32,16,64,32,128,32,64,16,32,8,16,4,8,2,4};

//cuarta secuencia
int ledS7[12] = {1,16,2,32,4,64,8,128,4,64,2,32};

//cuarta secuencia
int ledS8[14] = {1,2,4,8,16,32,64,128,64,32,16,8,4,2};

void setup() {

// La comunicacion serial sera a 9600 baudios
Serial.begin(9600);

// establecer pines a la salida para que pueda controlar el 74HC595
pinMode(data_pin, OUTPUT);
pinMode(latch_pin, OUTPUT);
pinMode(clock_pin, OUTPUT);

}

void loop() {

// send data only when you receive data:
if (Serial.available() > 0) {

letr = Serial.read();
val = Serial.parseInt();
Serial.print(letr);
Serial.println(val);

}

// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, val);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
//delay(500);

if (val == 1) { //Si es 1 inicie funcion de secuencia1
secuencia1();
}
if (val == 2) { //Si es 2 inicie funcion de secuencia2
secuencia2();
}
if (val == 3) { //Si es 3 inicie funcion de secuencia3
secuencia3();
}
if (val == 4) { //Si es 4 inicie funcion de secuencia4
secuencia4();
}
if (val == 5) { //Si es 5 inicie funcion de secuencia5
secuencia5();
}
if (val == 6) { //Si es 6 inicie funcion de secuencia7
secuencia6();
}
if (val == 7) { //Si es 7 inicie funcion de secuencia7
secuencia7();
}
if (val == 8) { //Si es 4 inicie funcion de secuencia8
secuencia8();
}

}

void secuencia1() {

//recorre el arreglo donde se difinio la secuencia
for (int i = 0; i < 4; i++) {
// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, ledS1[i]);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
delay(200);
}

}

void secuencia2() {
//recorre el arreglo donde se difinio la secuencia
for (int i = 0; i < 8; i++) {
// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, ledS2[i]);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
delay(200);
}
}

void secuencia3() {
//recorre el arreglo donde se difinio la secuencia
for (int i = 0; i < 8; i++) {
// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, ledS3[i]);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
delay(200);
}
}

void secuencia4() {
//recorre el arreglo donde se difinio la secuencia
for (int i = 0; i < 2; i++) {
// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, ledS4[i]);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
delay(200);
}
}

void secuencia5() {

//recorre el arreglo donde se difinio la secuencia
for (int i = 0; i < 12; i++) {
// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, ledS5[i]);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
delay(200);
}

}

void secuencia6() {
//recorre el arreglo donde se difinio la secuencia
for (int i = 0; i < 22; i++) {
// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, ledS6[i]);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
delay(200);
}
}

void secuencia7() {
//recorre el arreglo donde se difinio la secuencia
for (int i = 0; i < 12; i++) {
// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, ledS7[i]);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
delay(200);
}
}

void secuencia8() {
//recorre el arreglo donde se difinio la secuencia
for (int i = 0; i < 14; i++) {
// toma el latch_pin en bajo (LOW), para que los LEDs no cambien, mientras
// se envian los datos (en bits).
digitalWrite(latch_pin, LOW);
// cambiar los bits ej. 0000 0001 0002 0003...
shiftOut(data_pin, clock_pin, MSBFIRST, ledS8[i]);
//toma el latch_pin en alto (HIGH), para que los LEDs se iliminen
digitalWrite(latch_pin, HIGH);
// se hace una pausa antes del siguiente valor
delay(200);
}
}

codigo de processing

import controlP5.*;
import processing.serial.*;

ControlP5 cp5;

int colorDeFondo = color (215, 215, 215);
int val; // Data received from the serial port

RadioButton radioButton;

Serial serial; // definir la variable serial del tipo Serial
int lf = 10; // ASCII linefeed

void setup() {
size(400, 300);
noStroke();

// Print a list of the serial ports, for debugging purposes:
println("Puertos usados:");
printArray(Serial.list());

cp5 = new ControlP5(this);
radioButton = cp5.addRadioButton("radioButton")
.setPosition(20, 50)
.setSize(40, 20)
.setColorForeground(color(120))
.setColorActive(color(255))
.setColorLabel(color(0))
.setItemsPerRow(4)
.setSpacingColumn(50)
.setSpacingRow(20)
.addItem("Patron 1", 1)
.addItem("Patron 2", 2)
.addItem("Patron 3", 3)
.addItem("Patron 4", 4)
.addItem("Patron 5", 5)
.addItem("Patron 6", 6)
.addItem("Patron 7", 7)
.addItem("Patron 8", 8)
;

for (Toggle t : radioButton.getItems ()) {
//t.captionLabel().setColorBackground(color(255,80));
t.captionLabel().style().moveMargin(-7, 0, 0, -3);
t.captionLabel().style().movePadding(7, 0, 0, 3);
t.captionLabel().style().backgroundWidth = 45;
t.captionLabel().style().backgroundHeight = 13;
}

/*
cp5.addButton("Enviar")
.setPosition(100, 320)
.setSize(80,40)
;
*/

serial = new Serial(this, Serial.list()[0], 9600);
serial.bufferUntil(lf);
}

void draw() {
background(colorDeFondo);
}

//Majejando los radioButtons con el teclado
void keyPressed() {
switch(key) {
case('0'):
radioButton.deactivateAll();
break;
case('1'):
radioButton.activate(0);
break;
case('2'):
radioButton.activate(1);
break;
case('3'):
radioButton.activate(2);
break;
case('4'):
radioButton.activate(3);
break;
case('5'):
radioButton.activate(4);
break;
case('6'):
radioButton.activate(5);
break;
case('7'):
radioButton.activate(6);
break;
case('8'):
radioButton.activate(7);
break;
}
}

void controlEvent(ControlEvent evento) {

if (evento.isFrom(radioButton)) {

int total = 0;

total = (int)evento.getValue();

println("\nValor a ser enviado por Serial = " + total);
//serial.write(total+"");

serial.write("P"+total);

}
//println(serial.readString());
}

video

martes, 24 de marzo de 2015

laboratorio 5

laboratorio5

el laboratorio 5 se pretende controlar un LED RGB con una placa arduino mega o arduino 1 via pwm
con una interfaz grafica desde processing.

materiales

una placa arduino mega o arduino 1 + cable de comunicación + pc con ide arduino +ide de processing /controlIp5.
cables varios + 3 resistencias de 1kohm.
un led RGB

diagrama en protoboard con fritzing

esquema en fritzing

montaje del circuito

configuracion del led

interfaz grafica en processing

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 processing

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()[0],9600); // inicializamos el puerto serial a 9600 baudios
String puerto = Serial.list()[0]; //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("LABORATORIO 5")
.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,"Viavey Holguin",40,290,600,200);
texto4.setFont(createFont("Andalus",17));
texto4.setColorValue(0xff000000);
texto5 = new Textlabel(cp5,"Bioingenieria",40,305,600,200);
texto5.setFont(createFont("Andalus",17));
texto5.setColorValue(0xff000000);
texto6 = new Textlabel(cp5,"USCACA.VIANEY",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
}

video del laboratorio