domingo, 24 de noviembre de 2013


CERRADURA ELECTRONICA CON TOUCHSCREEN
(LABORATORIO FINAL) 

En este proyecto se trabajara en un sistema de seguridad desarrollado en arduino mega el cual usara una pantalla tatil tipo tft para visualizar el teclado digitaly por su gran cantidad de puertos nos permitira hacer un uso extra de puertos para el servomotor, en primera instancia el sistema se basa en un sistema electronico simple  que consta de el embebido arduino, un servo motor y un cargador de 5v. el sistema tiene una contraseña gravada en la memoria interna del microprocesador, lo que haremos es ingresar una serie de numeros, el programa compara estos numeros con la contraseña interna  si son iguales, el arduino procedera a enviarle una señal al servomotor el cual se activara dando como resultado la apertura del sistema.

ARDUINO MEGA

 PANTALLA TACTIL
SERVOMOTOR

CERRADURA TOUCHSCREEN


para lograr hacer uso del sevomotor hubo que descargar una libreria en la playground de arduino la cual nos  permite controlar el servomotor con mayor facilidad, y asi ahorrar varias lineas de codigo, ademas tambien se utilizaron las librerias touchscreen, para tomar los puntos de presion en la pantalla tactil y por medio de una serie de comando se establece un are para cada numero, y de esta forma se haga una lectura de cada numero. 
despues de haberse hecho la lectura de un numero se procedera a convertirlo en un string para poder hacer una suma de estos mismos y asi hacer una concatenacion de los numeros, los cuales ya concatenados, haran un dato el cual e comparara con el password que tambien es otro string  compuesto por numero del 1 al 4.

MATERIALES
  1. 1 arduino mega adk
  2. 1 Touch Shield V2.0
  3. 1 servomotor
LIBRERIAS

  1. SeeedTouchScreen.h  //libreria para el control del panel tactil
  2. TFTv2.h                     //libreria para el control de proyeccion en la pantalla
  3. Servo.h                      //libreria para el control del servomotor
DIAGRAMAS

DIAGRAMA DE MONTAJE EN PROTOBOARD


DIAGRAMA ESQUEMÁTICO


                                     DIAGRAMA PARA MONTAJE EN TARJETA PERFORADA

FOTOS

foto 1


foto 2

foto 3

foto 4

foto 5

       

foto 6

CÓDIGO ARDUINO



#include <stdint.h>
#include <TFTv2.h>
#include <SPI.h>
#include <stdint.h>
#include <SeeedTouchScreen.h>  
#include <Servo.h> 

#define YP A2   // must be an analog pin, use "An" notation!
#define XM A1   // must be an analog pin, use "An" notation!
#define YM 54   // can be a digital pin, this is A0
#define XP 57   // can be a digital pin, this is A3 

#define X 0
#define Y 1
#define R 30


TouchScreen ts = TouchScreen(XP, YP, XM, YM);
Servo myservo;
const int MAX = 8;
const int pulsoMin=650;
const int pulsoMax=2550;
String result;
int digito = 0;
String password;

int puntos[][2] = {
  {
    120,280  }
  ,
  { 
    40, 70  }
  ,
  {
    120, 70  }
  ,
  {
    200, 70  }
  ,
  { 
    40,140  }
  ,
  {
    120,140  }
  ,
  {
    200,140  }
  ,
  { 
    40,210  }
  ,
  {
    120,210  }
  ,
  {
    200,210  }
};


void setup(){
  Serial.begin(9600);
  TFT_BL_ON;                                      // turn on the background light
  Tft.TFTinit();       // init TFT library             
  Tft.drawString("BIENVENIDO" ,0,180, 4,RED);
  delay(1500);
  Tft.drawString("keypad"  ,65,230, 3,RED);
  delay(800);
  Tft.drawString("touchscreen" , 20,270, 3,RED);
  delay(800);
  Tft.fillScreen();
  

  for (int i=0; i <= 9; i++)
  {
    Tft.fillCircle(puntos[i][X], puntos[i][Y], 30,  GREEN); 
    Tft.drawNumber(i, puntos[i][X]-20, puntos[i][Y]-20, 6, WHITE); 
  }

  result = "";
  password= "1234";
}


void loop()
{
  Point p = ts.getPoint();
  p.x = map(p.x, TS_MINX, TS_MAXX, 0, 240);
  p.y = map(p.y, TS_MINY, TS_MAXY, 0, 320);

  if (p.z > __PRESURE) {
    for (int dig=0; dig<=9; dig++)
    {
      if ((p.x > puntos[dig][X]-R && p.x < puntos[dig][X]+R) && (p.y > puntos[dig][Y]-R && p.y < puntos[dig][Y]+R)) {

             result += String(dig);
            
        tap(dig, puntos[dig][X], puntos[dig][Y]);

    }
  }  
}  

  delay(100);
  Serial.println(result);
  if (password==result)
  {  Tft.fillScreen();
    Tft.drawString("ACCESO" ,40,130, 4,GREEN);
    Tft.drawString("CONCEDIDO" ,10,170, 4,GREEN);
   
delay(1000);
  myservo.attach(22);
  int pos = 0; 
  for(pos = 0; pos > 180; pos -= 1)  // goes from 0 degrees to 180 degrees 
  {                                  // in steps of 1 degree 
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
    
}     
}
}

void tap(int n, int x, int y)
{
  delay(10); //time between fills so you can see it happen
  Tft.fillCircle(x, y, R,  RED); 
  Tft.drawNumber(n, x-20, y-20, 6, GREEN);
  delay(100);
  Tft.fillCircle(x, y, R, GREEN); 
  Tft.drawNumber(n, x-20, y-20, 6, WHITE);
  Serial.println(n);
}





Publicado por en No hay comentarios:

martes, 29 de octubre de 2013

LABORATORIO NUMERO 12
En este laboratorio se usara una matriz de 8x8 de cátodo común para reemplazar la que se usaría en este laboratorio, la cual era una matriz de 8x5 de cátodo común. para controlar esta  matrix de LEDs de 8x8 se cableara a través de un IC Maxim MAX7219, para mostrar un mensaje letra por letra, desplazándose de derecha a izquierda, y así poder ahorra puertos de salida en en sistema embebido arduino.





Matriz de leds mono color (esquema).

MATRIZ DE LEDS BICOLOR (esquema).


este es un ejempo de muestreo de desplazamiento de leds encendido en secuencia para mostrar la letra W.


MAX 7219


 (esquema)



Es un multiplexor el cual utilizaremos para controlar la matriz de leds la cual recibirá la señales multiplezadas desde el IC, señal proveniente desde el arduino que estará conectado al computador, el cual trasmitira el texto a mostrar.

El MAX7219 impulsa ocho LEDs a la vez, y por los bancos con rapidez de conmutación de ocho ojos no ven los cambios. Cableado de una matriz es muy simple - si tiene una matriz común con el siguiente esquema:

conectar los pines con la etiqueta MAX7219 DP, A F ~ a los pines de las columnas que serán los cátodos de la matriz, respectivamente, y los MAX7219 pines etiquetados DIG0 ~ 7 para los ánodos de las columnas, respectivamente.

El circuito es muy sencillo, excepto que tenemos una resistencia entre 5V y MAX7219 pin 18. El MAX7219 es un controlador de LED de corriente constante, y el valor de la resistencia se utiliza para establecer el flujo de corriente a los LEDs.

MATERIALES
  1. 1 arduino mega adk
  2. matriz de leds 8x8 catodo comun
  3. computador
  4.  MAX7219
DIAGRAMA DE MONTAJE EN PROTOBOARD


DIAGRAMA ESQUEMÁTICO


 DIAGRAMA PARA MONTAJE EN TARJETA PERFORADA


 
FOTOS

foto 1


foto 2

foto 3

foto 4

 foto 5

 foto 6

 foto 7

foto 8


foto 9

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  = 6;
int CLK  = 7;
int LOAD = 8;
                     //DIN, CLK, LOAD, #chips
Matrix matrix = Matrix(DIN, CLK, LOAD, numChips);
 
void setup() {
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,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

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




Publicado por en 2 comentarios:
Suscribirse a: Entradas (Atom)