November 27, 2013 by alexandermejia

PROYECTO FINAL

DESCRIPCIÓN:

ES un móvil seguidor de línea negra haciendo uso de sensores infrarrojos, los cuales detectan la línea y envían una señal al resto del circuito. Allí, de acuerdo a la programación realizada, se tomará una decisión respecto a las acciones que eL carro debe realizar para mantenerse en el camino y llegar a la meta. Este diseño electrónico cuenta con dos sistemas: percepción y potencia.

Percepción

Es el sistema encargado de obtener la información del entorno para enviarla al sistema de comunicación en el cual se determinarán las acciones para el carro. En este caso se usarán leds infrarrojos, un emisor y un receptor, los cuales están encargados de detectar la línea negra que define el camino a seguir. En este caso se utilizarán dos sensores CNY70.

Potencia

La señal de salida obtenida de los sensores infrarrojos se convierte en la señal de entrada a la fase de programación, en la que interviene un módulo electrónico (Arduino) para el control del robot. Para ello se utilizará un componente SN754410NE quienes realizarán la función de indicar a los motores

Se debe crear un puente H para control de los motores

el puente H se usa para invertir el giro de un motor, pero también puede usarse para frenarlo (de manera brusca), al hacer un corto entre las bornas del motor, o incluso puede usarse para permitir que el motor frene bajo su propia inercia, cuando desconectamos el motor de la fuente que lo alimenta.

S1	S2	S3	S4	Resultado
1	0	0	1	El motor gira en avance
0	1	1	0	El motor gira en retroceso
0	0	0	0	El motor se detiene bajo su inercia
1	0	1	0	El motor frena (fast-stop)

MATERIALES:

2- Led infrarrojo CNY70
2 – Resistencias 220
2- Resistencias 47K
1- SN754410NE
1- Protoboard
2- Motores DC

PROCESO DE MONTAJE

Disponer de todos los materiales para poner en practica el laboratorio.

Realizamos el montaje de nuestro carro.

por ultimo montamos el resto de materiales para nuestro carro seguidor de linea.

CÓDIGO ARDUINO

#define M1A 19 //Motor 1A#define M1B 18 //Motor 1B
#define M2A 17 //Motor 2A

#define M2B 16 //Motor 2B

#define PIN_PWM 11 //Modulacion por ancho de pulso – Emular salida analogica con salida digital

#define VEL     100 //Velocidad

#define S1 0  //IZQ

#define S2 1  //DER

#define _UMBRAL_ 200 //Umbral de los sensores

unsigned long timeserial;

void setup (){

Serial.begin(9600);

timeserial = millis();

pinMode(M1A, OUTPUT);

pinMode(M1B, OUTPUT);

pinMode(M2A, OUTPUT);

pinMode(M2B, OUTPUT);

STOP(10000);

analogWrite(PIN_PWM, VEL);

}

void loop()

{

byte SDER = (analogRead(S1)> _UMBRAL_ )?0:1;

byte SIZQ = (analogRead(S2)> _UMBRAL_ )?0:1;

if(SDER && SIZQ)

STOP(0);

else if (!SDER && SIZQ)

DER(0);

else if (SDER && !SIZQ)

IZQ(0);

else

ADE(0);

if(millis() – timeserial > 500){

timeserial = millis();

Serial.print(“Sensor1: “);

//Serial.print(SDER);

Serial.print(analogRead(S1));

Serial.print(” Sensor2: “);

//Serial.println(SIZQ);

Serial.println(analogRead(S2));

}

}

void ATR(uint16_t time){

digitalWrite(M1A, HIGH);

digitalWrite(M1B, LOW);

digitalWrite(M2A, HIGH);

digitalWrite(M2B, LOW);

delay(time);

}

void ADE(uint16_t time){

digitalWrite(M1A, LOW);

digitalWrite(M1B, HIGH);

digitalWrite(M2A, LOW);

digitalWrite(M2B, HIGH);

delay(time);

}

void DER(uint16_t time){

//Llanta Izquierda

digitalWrite(M1A, HIGH);

digitalWrite(M1B, LOW);

//llanta Derecha

digitalWrite(M2A, LOW);

digitalWrite(M2B, HIGH);

delay(time);

}

void IZQ(uint16_t time){

//Llanta Izquierda

digitalWrite(M1A, LOW);

digitalWrite(M1B, HIGH);

//Llanta Derecha

digitalWrite(M2A, HIGH);

digitalWrite(M2B, LOW);

delay(time);

}

void STOP(uint16_t time){

digitalWrite(M1A, LOW);

digitalWrite(M1B, LOW);

digitalWrite(M2A, LOW);

digitalWrite(M2B, LOW);

delay(time);

}

VÍDEO DEL FUNCIONAMIENTO

November 9, 2013 by alexandermejia

LABORATORIO 12

DESCRIPCIÓN:

Controlar una matrix de LEDs de 8×5 cableada a través de un IC Maxim MAX7219, para mostrar un mensaje letra por letra, desplazandose de derecha a izquierda.

el procedimiento consiste en enviar un mensaje por medio de una interfaz gráfica y por medio de la comunicación serial.

MATERIALES:

1 — Matriz de leds 8×5
1 — MAX 7219CNG +092B
1 — plataforma arduino uno R3
1 — Resistencia 10k
1 — protoboard

PROCESO DE MONTAJE

Disponer de todos los materiales para poner en practica el laboratorio.

Realizamos el montaje en la protoboard de la matriz y el integrado.

INTERFAZ GRÁFICA

CÓDIGO ARDUINO

#include <Sprite.h>  
#include <Matrix.h>

int count = 0;

int x = 8;
int letra1 = 0;
int letra2 = 0;

int tiempoEspera = 0;

const int numChips = 1;
int DIN  = 16;
int CLK  = 17;
int LOAD = 18;
                     //DIN, CLK, LOAD, #chips
Matrix matrix = Matrix(DIN, CLK, LOAD, numChips);

void setup() {
  pinMode(16,OUTPUT);
  pinMode(17,OUTPUT);
  pinMode(18,OUTPUT);
  tiempoEspera = 150;
  Serial.begin(9600);
}

void loop() {
  if(Serial.available() > 0){
     byte dato = Serial.read();
     //si el dato esta entre A-Z o a-z
     if((64 < dato && dato < 91) || (96 < dato && dato < 123)){
        //pasamos a mayuscula el caracter
        byte caracterMayuscula = toUpperCase(dato);  
        letra1 = caracterMayuscula-65;
        mover();      
     }else {
       //si hay espacio
       if(dato == 32){
         letra1 = 26;
         mover();
        }        
     }
  }else{    
    letra1 = 26;
    mover();
  }    
}

void mover(){
  do{
    delay(tiempoEspera);    
    count--;
    x--;
    pintar();
  }while(x >= 0);
  x = 8;
  count = 6;
  letra2 = letra1;  
}

Sprite letras(int valor){
  //creamos los sprite con 5 pixeles de ancho y 5 pixelex de alto  
  int _width = 5;
  int _height = 5;
  switch(valor){
    case 0:
       //A
       return Sprite(_width, _height,
        B10001, B10001, B11111, B10001, B11111
      );
      break;
    case 1:
      //B
      return Sprite(5, 5,
        B11110, B10001, B11110, B10001, B11110
      );
      break;
    case 2:
      //C
      return Sprite(5, 5,
        B11111, B10000, B10000, B10000, B11111
      );
      break;
    case 3:
      //D
      return Sprite(5, 5,
        B11110, B10001, B10001, B10001, B11110
      );
      break;
    case 4:
      //E
      return Sprite(5, 5,
        B11111, B10000, B11111, B10000, B11111
      );
      break;
    case 5:
      //F
      return Sprite(5, 5,
        B10000, B10000, B11110, B10000, B11110
      );
      break;
    case 6:
      //G
      return Sprite(5, 5,
        B11111, B10001, B11111, B10000, B11111
      );
      break;  
    case 7:
      //H
      return Sprite(5, 5,
        B10001, B10001, B11111, B10001, B10001
      );
      break;
    case 8:
      //I
      return Sprite(5, 5,
        B11111, B00100, B00100, B00100, B11111
      );
      break;
    case 9:
      //J
      return Sprite(5, 5,
        B11100, B00100, B00100, B00100, B11111
      );
      break;
    case 10:
      //K
      return Sprite(5, 5,
        B10001, B10010, B11100, B10010, B10001
      );
      break;
    case 11:
      //L
      return Sprite(5, 5,
        B11111, B10000, B10000, B10000, B10000
      );
      break;
    case 12:
      //M
      return Sprite(5, 5,
        B10001, B10001, B10001, B10101, B11011
      );
      break;  
    case 13:
      //N
      return Sprite(5, 5,
        B10001, B10011, B10101, B11001, B10001
      );
      break;
    case 14:
      //O
      return Sprite(5, 5,
        B11111, B10001, B10001, B10001, B11111
      );
      break;
    case 15:
      //P
      return Sprite(5, 5,
        B10000, B10000, B11110, B10001, B11110
      );
      break;    
     case 16:
      //Q
      return Sprite(5, 5,
        B11111, B10011, B10001, B10001, B11111
      );
      break;
    case 17:
      //R
      return Sprite(5, 5,
        B10001, B10010, B11110, B10001, B11110
      );
      break;
    case 18:
      //S
      return Sprite(5, 5,
        B11110, B00001, B01110, B10000,B01110
      );
      break;
    case 19:
      //T
      return Sprite(5, 5,
        B00100, B00100, B00100, B00100, B11111
      );
      break;
    case 20:
      //U
      return Sprite(5, 5,
        B11111, B10001, B10001, B10001, B10001
      );
      break;
    case 21:
      //V
      return Sprite(5, 5,
        B00100, B01010, B10001, B10001, B10001
      );
      break;  
    case 22:
      //W
      return Sprite(5, 5,
        B10001, B11011, B10101, B10001, B10001
      );
      break;  
    case 23:
      //X
      return Sprite(5, 5,
        B10001, B01010, B00100, B01010, B10001
      );
      break;
    case 24:
      //Y
      return Sprite(5, 5,
        B00100, B00100, B01110, B10001, B10001
      );
      break;
    case 25:
      //Z
      return Sprite(5, 5,
        B11111, B01000, B00100, B00010, B11111
      );
      break;
    case 26:
      //Blanco
      return Sprite(5, 5,
        B00000, B00000, B00000, B00000, B00000
      );
      break;    
  }
}

void pintar(){  
  matrix.clear();
  //se coloca el Sprite en pantalla
  matrix.write(x, 0, letras(letra1));
  if(count >= 0){
    matrix.write(x - 8, 0, letras(letra2));
  }
}

CÓDIGO PROCESSING

import controlP5.*;
//se carga la libreria Serial
import processing.serial.*;
// definir la variable cp5 del tipo ControlP5
ControlP5 cp5;
// definir la variable puerto del tipo Serial
Serial puerto;
// definir la variable text del tipo Textfield
Textfield text;

void setup(){
  //tamaño de la ventana
   size(250,160);

   //se crea el objeto controlP5
   cp5 = new ControlP5(this);

   text = cp5.addTextfield("text")
             .setPosition(20,30)
             .setSize(200,40)
             .setFont(createFont("arial",20))
             .setAutoClear(false);

          cp5.addButton("Enviar")
              .setValue(1)
              .setPosition(20,100)
              .setSize(40,30)
              .setId(2);

   String COM = Serial.list()[0];
   //comunicacion serial a 9600bps
   puerto = new Serial(this, COM, 9600);
}

void draw(){
   background(#000000);
}

void controlEvent(ControlEvent theEvent){  
  if(theEvent.isAssignableFrom(Button.class)){  
   //se envia cada caracter de la cadena
    for(int i = 0; i < text.getText().length(); i++){  
       char dato = text.getText().charAt(i);    
       puerto.write(dato);
    }
  }
}

VÍDEO DEL FUNCIONAMIENTO

November 9, 2013 by alexandermejia

LABORATORIO 14

DESCRIPCIÓN:

Utilizando un LCD shield, mostrar con numeros grandes(caracteres personalizados), los datos capturados en el Arduino con una fotocelda

MATERIALES:

1 — Resistencia 10k
1 — display lcd 16*2
1 — fotocelda (LRD o Cds)
1 — potenciometro 10k
1 — plataforma arduino uno R3

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

Disponer de todos loa materiales para el laboratorio.

A continuación vamos a seguir con el montaje de los materiales.

CÓDIGO ARDUINO

#include <LiquidCrystal.h>; // se incluye la liberia para el LCD
int foto=0;
int leer;
//se inicializa la libreria con el numero de pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
//se define la variable text de tipo String
byte Modo1[8] = {31,31,31,0,0,0,0,0};
byte Modo2[8] = {0,0,0,0,0,31,31,31};
byte Modo3[8] = {31,31,31,0,0,0,31,31};
byte Modo4[8] = {28,30,31,31,31,31,30,28};
byte Modo5[8] = {7,15,31,31,31,31,15,7};
byte Modo6[8] = {31,31,31,31,31,31,31,31};
byte Modo7[8] = {0,0,0,0,0,0,0,0};

void setup()
{
  lcd.createChar(1, Modo1);
  lcd.createChar(2, Modo2);
  lcd.createChar(3, Modo3);
  lcd.createChar(4, Modo4);
  lcd.createChar(5, Modo5);
  lcd.createChar(6, Modo6);
  lcd.createChar(7, Modo7);
  lcd.begin(16, 2);
  Serial.begin(9600);    
  }

void loop()
{
  int Numeros [10][6] =
  {
    {
      6,1,6,6,2,6    }
    ,
    {
      1,6,7,2,6,2    }
    ,
    {
      1,3,4,5,2,2    }
    ,
    {
      1,3,4,2,2,4    }
    ,
    {
      6,2,6,7,7,6    }
    ,
    {
      6,3,1,2,2,4    }
    ,
    {
      6,3,1,6,2,4    }
    ,
    {
      1,1,4,7,6,7    }
    ,
    {
      5,3,4,5,2,4    }
    ,
    {
      5,3,6,7,7,6    }
    ,
  };

  leer = analogRead(foto);
  int u=leer%10;
  int u1=((leer-u)%100)/10;
  int u2=(leer-(u1*10)-u)/100;
  int Valor [3] = {u2,u1,u};

  for (int p=0;p<=2;p++){
    for (int j=0;j<=1;j++){
      for (int k=0;k<=2;k++){
        lcd.setCursor(k+(p*4),j);
        if (j==0) {
          lcd.write(Numeros [Valor[p]][k]);
          lcd.setCursor(13,j);
          lcd.println("Ohm");
        }
        else if (j==1){
          lcd.write(Numeros [Valor[p]][k+3]);
        }
      }
    }
  }

  delay (1000);
 }

VÍDEO DEL FUNCIONAMIENTO

October 23, 2013 by alexandermejia

LABORATORIO 13

DESCRIPCIÓN:

Utilizando Processing, manipular en la pantalla del computador una figura animada, a partir de los datos leídos desde el Arduino y un Joystick shield.

MATERIALES:

-Hardware Arduino UNO

-Hardware JoystickShield (para Arduino)

PROCESO DE MONTAJE

Disponer de todos loa materiales para el laboratorio.

seguimos con el montaje del Joystick shield en el arduino.

VENTA DEL PROCESSING

CÓDIGO ARDUINO

char button0=3, button1=4, button2=5, button3=6;void setup(void)
{pinMode(button0, INPUT); //Set the Joystick button 0 as an input
digitalWrite(button0, HIGH); //Enable the pull-up resistor on button 0

pinMode(button3, INPUT); //Set the Joystick button 3 as an input
digitalWrite(button3, HIGH); //Enable the pull-up resistor on button 3

Serial.begin(9600); //Turn on the Serial Port at 9600 bps
}

void loop(void)
{

//envia datos a Processing, dependiendo de la accion realizada en el joystickShield
if(analogRead(1)>800)
{
Serial.print(1);
}
else if(analogRead(1)<200)
{
Serial.print(2);
}

if(analogRead(0)>800)
{
Serial.print(3);
}
else if(analogRead(0)<200)
{
Serial.print(4);
}

if(digitalRead(button0)==0)
{
Serial.print(5);
}

if(digitalRead(button3)==0)
{
Serial.print(6);
}

//Wait for 100 ms, then go back to the beginning of ‘loop’ and repeat.
delay(100);
}

CÓDIGO PROCESSING
import processing.serial.*;
int x=550;
int y=450;//el punto centro de la pantalla
int grados=0;//inicio de grados en el que se encuentra el triangulo
Serial port;//puerto por el que vamos a recibir los datos
int valor = 0;
//int valor2=550;
void setup()
{
//println(Serial.list());
port = new Serial(this, Serial.list()[0], 9600);
//new Serial(this, COM[5], 9600);
size(1000,600);//tamaño de la ventana
frameRate(100);// especifica el numero de fotogramas que muestra por segundo
smooth();//suavizar
fill(25,90,40);//color del triangulo ROJO
}

void draw ()
{
while (port.available() > 0)
{
String cadena =”00″+port.readString(); //Lectura de datos desde arduino
valor = int(cadena.substring(2,cadena.length()));
println(cadena + “:” + valor);
}

background (0,0,0);//color de fondo
pushMatrix();//entrada a la pila de matriz
translate(x, y);//trasladamos el triagulo en pantalla con respecto a su estado
rotate(radians(grados));//rotamos el triangulo el numero de grados indicado
triangle(0, 40, -30, -40, 30, -40);//pintar el triangulo
popMatrix();//restaura la pila de matriz

//Condiciones que dependen del los valores recibidos desde arduino (movimientos de joystick)
if (valor == 1)
{
valor=0;
y-=10;
if (y<10) y=30;
}

if (valor == 2)
{
valor=0;
y+=10;
if (y>400) y=400;
}

if (valor == 3)
{
valor=0;
x+=10;
if (x>400) x=400;
}

if (valor == 4)
{
valor=0;
x-=10;
if (x<10) x=30;
}

if (valor == 5)
{
valor=0;
grados+=5;
if (grados>360) grados=0;

}

if (valor == 6)
{
valor=0;
grados-=5;
if (grados<0) grados=360;
}

}

VÍDEO DEL FUNCIONAMIENTO

October 16, 2013 by alexandermejia

LABORATORIO 11

DESCRIPCIÓN:

Controlar una matrix de LEDs de 8×5 cableada directamente al Arduino, para mostrar un mensaje letra por letra, desplazándose de derecha a izquierda.

MATERIALES:

26— resistencias de 330 ohmios
1 — una matrix de leed 8×5
1 — plataforma arduino uno R3
1 — protoboard

PROCESO DE MONTAJE

Disponer de todos loa materiales para el laboratorio a seguir.

seguimos con el montaje en la protoboard.

CÓDIGO ARDUINO

//Se incluye la libreria FrequencyTimer2
#include <FrequencyTimer2.h>

//matrix 5x5
//se declara la variable temCol de tipo entero inicializada en 5
int temCol = 5; 
//se declara la variable temFil de tipo entero inicializada en 5
int temFil = 5; 

//se definen las matrices de letras [A-Z]
#define A { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}

#define B { \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0} \
}

#define C { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}

#define D { \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0} \
}

#define E { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}

#define F { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0} \
}

#define G { \
{1, 0, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1} \
}

#define H { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}

#define I { \
{1, 1, 1, 1, 1}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{1, 1, 1, 1, 1} \
}

#define J { \
{1, 1, 1, 1, 1}, \
{1, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{1, 1, 1, 0, 0} \
}

#define K { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 1, 0}, \
{1, 1, 1, 0, 0}, \
{1, 0, 0, 1, 0}, \
{1, 0, 0, 0, 1} \
}

#define L { \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}

#define M { \
{1, 1, 0, 1, 1}, \
{1, 0, 1, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}

#define N { \
{1, 0, 0, 0, 1}, \
{1, 1, 0, 0, 1}, \
{1, 0, 1, 0, 1}, \
{1, 0, 0, 1, 1}, \
{1, 0, 0, 0, 1} \
}

#define O { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1} \
}

#define P { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0} \
}

#define Q { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 1, 1}, \
{1, 1, 1, 1, 1} \
}

#define R { \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 1, 0}, \
{1, 0, 0, 0, 1} \
}

#define S { \
{0, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{0, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0} \
}

#define T { \
{1, 1, 1, 1, 1}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0} \
}

#define U { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1} \
}

#define V { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 0, 1, 0}, \
{0, 0, 1, 0, 0} \
}

#define W { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 1, 0, 1}, \
{1, 1, 0, 1, 1}, \
{1, 0, 0, 0, 1} \
}

#define X { \
{1, 0, 0, 0, 1}, \
{0, 1, 0, 1, 0}, \
{0, 0, 1, 0, 0}, \
{0, 1, 0, 1, 0}, \
{1, 0, 0, 0, 1} \
}

#define Y { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0} \
}

#define Z { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 1, 0}, \
{0, 0, 1, 0, 0}, \
{0, 1, 0, 0, 1}, \
{1, 1, 1, 1, 1} \
}

#define blanco { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0} \
}

//se declara la variable col2 de tipo intero enicializada en 0
int col2 = 0;
//se declara la variable tiempoEspera de tipo entero inicializada en 150
int tiempoEspera = 150;
//se declara la variable numLetras de tipo entero inicializada en 27
const int numLetras = 27;
//se declara la variable letras de tipo matrix de entero 
int letras [numLetras][5][5] = {
  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,blanco
};

//matrix 5x8
//se declara la variable numCol de tipo entero inicializada en 5
const int numCol = 5;
//se declara la variable numFil de tipo entero inicializada en 8
const int numFil = 8;
//se declara la variable matrixLeds de tipo matrix de entero 
int matrixLeds[numFil][numCol];

//filas
//se declara la variable constante fil de tipo vector de entero
const int fil[numFil] = {
  10,14,9,12,2,8,3,6};

//columnas
//se declara la variable constante col de tipo vector de entero inicializada en 5
const int col[numCol] = {
  13,4,5,11,7};

void setup(){  
  for(int i = 0; i < numFil; i++) {
    //pines de salida
    pinMode(fil[i], OUTPUT);
    //Se apaga el led,
    digitalWrite(fil[i],LOW);
  }

  for(int i = 0; i < numCol; i++) {
    //pines de salida
    pinMode(col[i], OUTPUT);
    //Se apaga el led,
    digitalWrite(col[i],LOW);  
  }
  //comunicacion serial a 9600bps
  Serial.begin(9600);  

  FrequencyTimer2::disable();
  FrequencyTimer2::setPeriod(2000);
  FrequencyTimer2::setOnOverflow(display);  
}

void loop(){   
   if(Serial.available() > 0) {
     byte dato = Serial.read(); 
     //si el dato esta entre A-Z o a-z
     if((64 < dato && dato < 91) || (96 < dato && dato < 123)){
       //pasamos a mayuscula el caracter
       byte caracterMayuscula = toUpperCase(dato);
       //cargamos el caracter en la matrix matrixLeds 
       //y movemos cada pixel de posicion
       moveCharater(caracterMayuscula-65);       
     } else 
       //si hay un espacio
       if(dato == 32){
         moveCharater(numLetras-1);
       } 
   } else {
     moveCharater(numLetras-1);
   }  
}

void obtenerCaracter(int posicionCaracter){
   int posicion = numFil - temCol;  
   for(int j = 0; j < temFil; j++) {
     for(int i = 0; i < temCol; i++) {
       matrixLeds[i+posicion][temCol-1-j] = letras[posicionCaracter][j][i];       
     }     
  }
}

void siguinteCaracter(int posicionCaracter, int temFila){
  int matrixTem[temFil][temCol];

  for(int i = 0; i < temFil; i++) {
     for(int j = 0; j < temCol; j++) {
       matrixTem[j][4-i] = letras[posicionCaracter][i][j];
     } 
  }

  for (int j = 0; j < numCol; j++){
    matrixLeds[numFil-1][j] = matrixTem[temFila][j];
  } 
}

void moveCharater(int posicionCaracter){  
  int temFila = 0;

  do{       
    for(int i = 0; i < numCol; i++) {
      for(int j = 0; j < numFil-1; j++) {
        matrixLeds[j][i] = matrixLeds[j+1][i];
      }
    }    
    siguinteCaracter(posicionCaracter, temFila);    
    delay(tiempoEspera);     

    temFila++;    
  } while(temFila < numFil);  
}

void display(){  
   digitalWrite(col[col2], HIGH); 
   col2++;

   if (col2 == 5) {
      col2 = 0;
   }
   for (int row2 = 0; row2 < 8; row2++) {
      if (matrixLeds[row2][col2] == 1) {
         digitalWrite(fil[row2], HIGH); 
      }
      else {
         digitalWrite(fil[row2], LOW); 
      }
   }
   digitalWrite(col[col2], LOW); 
}

CÓDIGO PROCESSING

//se carga la libreria ControlP5
import controlP5.*;
//se carga la libreria Serial
import processing.serial.*;
// definir la variable cp5 del tipo ControlP5
ControlP5 cp5; 
// definir la variable puerto del tipo Serial
Serial puerto;
// definir la variable text del tipo Textfield
Textfield text;

void setup(){
  //tamaño de la ventana 
   size(250,160); 

   //se crea el objeto controlP5 
   cp5 = new ControlP5(this);

   text = cp5.addTextfield("text")
             .setPosition(20,30)
             .setSize(200,40)
             .setFont(createFont("arial",20))
             .setAutoClear(false); 

          cp5.addButton("Enviar")
              .setValue(1)
              .setPosition(20,100)
              .setSize(40,30)
              .setId(2); 

   String COM = Serial.list()[0];
   //comunicacion serial a 9600bps
   puerto = new Serial(this, COM, 9600);
}

void draw(){
   background(#000000); 
}

void controlEvent(ControlEvent theEvent){  
  if(theEvent.isAssignableFrom(Button.class)){   
   //se envia cada caracter de la cadena 
    for(int i = 0; i < text.getText().length(); i++){   
       char dato = text.getText().charAt(i);    
       puerto.write(dato);       
    }
  }
}

VÍDEO DEL FUNCIONAMIENTO

October 10, 2013 by alexandermejia

LABORATORIO 9

DESCRIPCIÓN:

Para este laboratorio se busca Controlar desde el Arduino, un Display LED de 7 Segmentos, a través de un IC 74HC595, para mostrar los números del 0 a 9, dependiendo de la posición del Potenciómetro.

MATERIALES:

2 — resistencias de 330 ohmios
1 — Display 7 segmentos anodo comun
1 — potenciometro 10kohmios
1 — plataforma arduino uno R3
1 — integrado IC 74HC595
1 — protoboard

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

Disponer de todos loa materiales para el laboratorio a seguir.

Realizar el montaje en la protoboard de el integrado, el potenciometro 10k y el display de 7 segmentos de ánodo común.

montaje del resto de materiales ala protoboard.

CÓDIGO ARDUINO

#define pines 3 //Las variable maxleds de 8 elementos
#define pot A0    //Las variable pot con el pin A0

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

// creamos una tabla para los numeros del 0 al 9
int num1[1]={249};
int num2[1]={164};
int num3[1]={176};
int num4[1]={153};
int num5[1]={146};
int num6[1]={131};
int num7[1]={248};
int num8[1]={128};
int num9[1]={144};
int num0[1]={192};

// Solo se ejecuta una vez, al iniciar o resetear el Arduino
void setup ()
{
  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()
{
  int valor = analogRead(pot); // lee el valor del potenciometro
  int i=map(valor, 0, 1023, 0, 10); // hace un mapeo o conversion 
  rutina(i);                   // llama a la funcion rutina
}

void rutina(int i) //funcion para enceder el led
{
   switch(i)
  {
  case 0: //hacer algo cuando sea igual a 0
    for(int j=0;j<1;j++)
    {
      activacion(num0[j]);
      delay(60);
    }
    break;
  case 1: //hacer algo cuando sea igual a 1
    for(int j=0;j<1;j++)
    {
      activacion(num1[j]);
      delay(60);
    }
    break;
  case 2: //hacer algo cuando sea igual a 2
    for(int j=0;j<1;j++)
    {
      activacion(num2[j]);
      delay(60);
    }
    break;
  case 3: //hacer algo cuando sea igual a 3
    for(int j=0;j<1;j++)
    {
      activacion(num3[j]);
      delay(60);
    }
    break;
  case 4: //hacer algo cuando sea igual a 4
    for(int j=0;j<1;j++)
    {
      activacion(num4[j]);
      delay(100);
    }
    break;   
  case 5: //hacer algo cuando sea igual a 5
    for(int j=0;j<1;j++)
    {
      activacion(num5[j]);
      delay(60);
    }
    break;  
   case 6: //hacer algo cuando sea igual a 6
    for(int j=0;j<1;j++)
    {
      activacion(num6[j]);
      delay(60);
    }
    break;  
    case 7: //hacer algo cuando sea igual a 7
    for(int j=0;j<1;j++)
    {
      activacion(num7[j]);
      delay(60);
    }
    break;  
    case 8: //hacer algo cuando sea igual a 8
    for(int j=0;j<1;j++)
    {
      activacion(num8[j]);
      delay(60);
    }
    break; 
    case 9: //hacer algo cuando sea igual a 9
    for(int j=0;j<1;j++)
    {
      activacion(num9[j]);
      delay(60);
    }
    break;   
  }
}

// Uso de la orden interna shiftout función 
void activacion(int i)
{
  digitalWrite (pinLatch, LOW); // señal al 595 para escuchar los datos 
  shiftOut (pinDato, pinReloj, MSBFIRST, i); // Señal de la 595 que estoy hecho enviando   
  digitalWrite (pinLatch, HIGH); // sendSerialData1   
  delay(50);  
}

VÍDEO DEL FUNCIONAMIENTO

September 13, 2013 by alexandermejia

LABORATORIO 7

DESCRIPCIÓN:

En esta practica se controlaran 8 leds desde el ARDUINO por medio de un integrado IC 74HC595, definiendo desde una interfaz gráfica de processing que lee el led que debe de estar encendido o apagado.

MATERIALES:

8— resistencias de 330 Ω

1 — plataforma arduino uno R3

1 — protoboard

8 — led rgb

1— Integrado IC 74HC595

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

Disponer de todos loa materiales para el laboratorio a seguir.

Conectar las 8 resistencias en la protoboard como los leds, IC 74HC595 estas resistencias se conectan a tierra.

CÓDIGO ARDUINO

int pinlatch = 2; // Baja cuando se desea que el intgrado lea
int pinreloj = 3; // Reloj utilizado por la instruccion shiftout para alternar
int pindato = 4; // instrucion que se utiliza para pasar al siguiente bit

// Solo se ejecuta al iniciar o reiniciar el arduino
void setup()
{
// Se define que los pines seran de salida
pinMode(pinlatch,OUTPUT);
pinMode(pinreloj,OUTPUT);
pinMode(pindato,OUTPUT);
Serial.begin(9600); //Se define la comunicación serial a 9600bps
}

// Se recibe la información de manera serial desde processing
void loop()
{
if (Serial.available()>0) // instruccion para verificar si hay datos en el puerto serial
{

int Valor = Serial.read(); // lee la opcion o slider que se esta utilizando en el puerto serial
On (Valor);
}
}
// instruccion para enviar los datos al Integrado y se usa shiftOut para que el valor se lea en los ocho Leds
void On(int Valor)
{
digitalWrite(pinlatch, LOW); // señal del integrado para leer datos
shiftOut(pindato, pinreloj, MSBFIRST, Valor); // Señal del integrado que se envia
digitalWrite(pinlatch, HIGH); //escritura serial
}

CÓDIGO DE PROCESSING

import controlP5.*; // importamos la libreria ControlP5
import processing.serial.*; // importamos para utilizar la liberia processing.serial
Serial serial; // Se define la variable serial del tipo Serial
ControlP5 cp5; // definimos que la variable cp5 del tipo ControlP5
Textlabel texto1; // se define que la variable texto1 sera de tipo textlabel

// 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()
{
size(590, 180); // tamaño de la ventana
noStroke(); // no dibujar el border de los circulos
cp5 = new ControlP5(this); // crear el objeto ControlP5
serial = new Serial(this, Serial.list()[0],9600); // instruccion para inicializar el puerto serial a 9600 baudios
// crear un botón para encender/apagar cada LED
for (int i=0; i<led.length; i++)
cp5.addToggle(“led”+i, 35+i*70, 80, 30, 30);
// Titulo de la ventana
texto1 = cp5.addTextlabel(“label”)
.setText(“LABORATORIO #08”) //Definimos lo que tendra el texto agregado
.setPosition(175,130) //Definimos la pocision en la que se pondra el letrero
.setColorValue(0xff090808) //Definimos el color de la ventana
.setFont(createFont(“Arial BLack”,22)); //Definimos tipo de letra para la interfaz
}

// dibujar cada frame
void draw()
{
background(0x721515); // color del fondo
// un circulo para representar cada LED
for (int i=0; i<led.length; i++) {
// definir el color de relleno, 0=apagado, 1=encendido
fill(led[i] == 0 ? color(255,255,255) :color(0,255,0));
// dibujar un circulo con ese color
ellipse(50+i*70, 40, 50, 50);
}
}

// actuar cuando ocurra un evento con los Sliders
public void controlEvent(ControlEvent theEvent) {
// guardar el nombre y valor del evento
String nombre = theEvent.getController().getName();
int valor = int(theEvent.getController().getValue());
int resultado=0; // creamos una variable para guardar la posicion del led encendido

for (int i=0; i<led.length; i++)
{
if (nombre.equals(“led”+i))
{
led[i] = valor;
}
resultado += (led[i] << i); // Instruccion para hacer un desplazamiento de la posicion del arreglo y manda el valor
}

serial.write (resultado); // instruccion para enviar por el puerto serial el nombre y el valor
}

INTERFAZ DE PROCESSING

VÍDEO DEL FUNCIONAMIENTO

September 11, 2013 by alexandermejia

LABORATORIO 6

DESCRIPCIÓN:

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.

MATERIALES:

3— resistencias de 220 ohmios

1 — plataforma arduino uno R3

1 — protoboard

1 — led rgb

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

Disponer de todos los materiales para el laboratorio.

ahora procedemos a instalar los materiales en la protoboard quedando algo como esto.

CÓDIGO ARDUINO

#define MAXLED 3

int led[MAXLED] = {

3,5,6};

int valor = 0;

int i = 0;

void setup()

{

Serial.begin(9600);

for(int i = 0; i < MAXLED ; i++)

{

pinMode(led[i], OUTPUT);

}

void loop()

{

if(Serial.available() > 0)

{

valor = Serial.read();

if(valor == ‘B’)

i = 0;

if(valor == ‘G’)

i = 1;

if(valor == ‘R’)

i = 2;

valor = Serial.parseInt();

analogWrite(led[i], valor);

}

CÓDIGO DE PROCESSING

import processing.serial.*;

import controlP5.*;

ControlP5 cp5;

Slider sldR, sldG, sldB;

Serial serial;

void setup() {

size (600, 250);

cp5 =new ControlP5(this);

sldR = cp5.addSlider (“R”, 0, 255, 128, 40, 40, 300, 40);

sldG = cp5.addSlider (“G”, 0, 255, 128, 40, 100, 300, 40);

sldB = cp5.addSlider (“B”, 0, 255, 128, 40, 160, 300, 40);

String puerto = Serial.list()[0];

serial = new Serial (this, puerto, 9600);

}

void draw()

{

background(80, 80, 80);

}

void controlEvent(ControlEvent evento)

{

String nombre = evento.getController().getName();

int valor = int(evento.getController().getValue());

println(nombre+”:”+valor);

serial.write(nombre+valor);

}

INTERFAZ DE PROCESSING

VÍDEO DEL FUNCIONAMIENTO

September 10, 2013 by alexandermejia

LABORATORIO 5

DESCRIPCIÓN:

Este ejercicio consiste en ocupar el Arduino para controlar el encendido de un LED RGB mediante 3 potenciómetros. Cada color del LED se enciende en ciertos intervalos y este lo controlamos mediante 3 potenciómetro.

MATERIALES:

3— resistencias de 220 ohmios

1 — plataforma arduino uno R3

1 — protoboard

1 — led rgb

3— Potenciometros

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

Disponer de todos los materiales para el laboratorio.

En el siguiente paso procedemos a montar los respectivos potenciometora como las resistencias.

En este paso veremos el montaje de todos los materiales del laboratorio en la protoboard.

CÓDIGO ARDUINO

#define potRED A0
#define potGRE A1
#define potBLU A2

int Red = 9;
int Gre = 10;
int Blu = 11;

// Ciclo para activar los tres pines como salida
void setup() {
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(potRED, INPUT);
pinMode(potGRE, INPUT);
pinMode(potBLU, INPUT);
}

// Recibe la información de manera serial del processing
// diferenciando la información del color rojo por la letra “R”
// la información del color verde por la letra “G” y
// la información del color azul por la letra “B”
void loop() {
int R = analogRead(potRED);
int TimeR = map(R,0,1023,0,255);
analogWrite(Red, TimeR);
int G = analogRead(potGRE);
int TimeG = map(G,0,1023,0,255);
analogWrite(Gre, TimeG);
int B = analogRead(potBLU);
int TimeB = map(B,0,1023,0,255);
analogWrite(Blu, TimeB);
}

VÍDEO DEL FUNCIONAMIENTO

September 10, 2013 by alexandermejia

LABORATORIO 4

DESCRIPCIÓN:

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.

MATERIALES:

8— resistencias de 220 ohmios

1 — plataforma arduino uno R3

1 — protoboard

8 — leds

DIAGRAMA:

ESQUEMÁTICO

PROCESO DE MONTAJE

Disponer de todos los materiales para el laboratorio.

En este paso vamos a ver el montaje de todos los materiales en su respectivo arduino por medio de sus salidas digitales.

en este paso vamos a realizar lo que es la interfaz gráfica con processing.

Nota: para trabajar con interfaz en processing hay que descargar la libreria controlp5 y luego meterlo en la carpeta libraries de preocessing.

INTERFAZ GRÁFICA DE PROCESSING

CÓDIGO DEL ARDUINO

#define MAXLED 8

int led [MAXLED]={6,7,8,9,10,11,12,13};
int valor=0;
int i=0;
int t_on=500;
int t_off=100;
int inc=1;

void setup(){
Serial.begin(9600);
for (int i=0; i<MAXLED; i++){
pinMode(led[i], OUTPUT);
}
}

void loop() {

if (Serial.available()>0){
valor=Serial.read();
if(valor==’t’)
t_on=Serial.parseInt();

if(valor==’q’)
t_off=Serial.parseInt();

}
on(led[i], t_on);
off(led[i], t_off);
i+=inc;
if (i>MAXLED-1) inc=-1;
if (i==0) inc=+1;}

void on(int led, int ms) {
digitalWrite(led, HIGH);
delay(ms);
}

void off(int led, int ms) {
digitalWrite(led, LOW);
delay(ms);

}

CÓDIGO DE PROCESSING

import processing.serial.*;
import controlP5.*;
ControlP5 cp5;
Slider slider1;
Button boton1;
Knob perilla1;
Serial puerto;
Textlabel texto1;

void setup(){
size(600,400);
puerto = new Serial(this, Serial.list()[0],9600);
cp5 = new ControlP5(this);
slider1 = cp5.addSlider(“t”,0,1000,200,40,40,300,40);
slider1.setColor(new CColor (0xFF00FF00,0xFF555555,0xFF009F00,0xFFFFFFFF,0xFFFFFFFF));
boton1 = cp5.addButton(“aceptar”,50,40,100,80,40);
boton1.setColor(new CColor (0xFF00FF00,0xFF555555,0xFF009F00,0xFFFFFFFF,0xFFFFFFFF));
perilla1 = cp5.addKnob(“q”,0,500,150,400,40,100);
perilla1.setColor(new CColor (0xFF00FF00,0xFF555555,0xFF009F00,0xFFFFFFFF,0xFFFFFFFF));

texto1 = cp5.addTextlabel(“label1”)
.setText(“ALEXANDER MEJIA”)
.setPosition(200,300)
.setColorValue(0xffffffFF)
.setFont(createFont(“Arial”,20));
}

void draw()
{
background(50,30,100);
}

void controlEvent (ControlEvent theEvent){

String nombre=theEvent.getController().getName();
int valor=int(theEvent.getController().getValue());
println( nombre + “:” + valor);
puerto.write(nombre+valor);

}

DESCRIPCIÓN:

Percepción

Potencia

Se debe crear un puente H para control de los motores

MATERIALES:

PROCESO DE MONTAJE

CÓDIGO ARDUINO

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

PROCESO DE MONTAJE

INTERFAZ GRÁFICA

CÓDIGO ARDUINO

CÓDIGO PROCESSING

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

CÓDIGO ARDUINO

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

PROCESO DE MONTAJE

VENTA DEL PROCESSING

CÓDIGO ARDUINO

CÓDIGO PROCESSING

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

PROCESO DE MONTAJE

CÓDIGO ARDUINO

CÓDIGO PROCESSING

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

CÓDIGO ARDUINO

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

CÓDIGO ARDUINO

CÓDIGO DE PROCESSING

INTERFAZ DE PROCESSING

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

CÓDIGO ARDUINO

CÓDIGO DE PROCESSING

INTERFAZ DE PROCESSING

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

DIAGRAMA

ESQUEMÁTICO

PROCESO DE MONTAJE

CÓDIGO ARDUINO

VÍDEO DEL FUNCIONAMIENTO

DESCRIPCIÓN:

MATERIALES:

DIAGRAMA:

ESQUEMÁTICO

PROCESO DE MONTAJE

INTERFAZ GRÁFICA DE PROCESSING

CÓDIGO DEL ARDUINO

CÓDIGO DE PROCESSING

VÍDEO DEL PROCEDIMIENTO