Sensor Pir HCSR501

Diagrama de conexión más código arduino.

Módulo SIM800L

Diagrama de conexión más código arduino.

Módulo Reloj DS3231

Diagrama de conexión más código arduino.

LCD 1602 2004 con adaptador I2C

Diagrama de conexión más código arduino.

Sensor por ultrasonido HCSR04

Diagrama de conexión más código arduino.

miércoles, 28 de marzo de 2018

Display matricial 8x8 con Arduino SPI y MAX7219



La matrices led de 8x8 son elementos extremadamente útiles para desplegar mensajes que puedan ser visibles desde la distancia. Estos elementos funcionan activando cada led en la matriz de forma secuencial, lo cual se logra multiplexando en tiempo las entradas. Esta multiplexación podemos lograrla "manualmente"  por medio de un microcontrolador o circuito de lógica secuencial para controlar  el display, pero sería un verdadero desperdicio de recursos ya que existen circuitos integrados como el Max7219 que son capaces de llevar a cabo esta tarea y tiene un muy bajo costo.

Las matrices de leds disponibles en nuestra tienda vienen montadas sobre una placa de  circuito que incluye el circuito integrado Max7219, a la vez que nos permiten comunicarnos por medio de protocolos SPI, facilitándonos así la conexión de varios displays a vez con sólo 5 cables. El control de estos módulos podemos lograrlo por  medio de la librería Max72xxPanel que puedes descargar aquí. 

De esta forma podemos ver la presentación de 4 displays juntos que se puede controlar con la misma librería y con la misma facilidad de un sólo display y así mismo podemos juntar tantos displays consecutivos como se quiera para agrandar nuestra pantalla sólo conectando la salida de uno a la entrada del siguiente e incluso podemos colocar varios paneles de displays uno encima del otro y sólo modificando una par de líneas de código en nuestra librería podemos hacer que las letras sean tan grandes como lo las dos  líneas de matrices, la versatilidad entonces es total. Cabe mencionar que la librería también nos permite regular el brillo de los displays, cambiar el tamaño de las letras y representar caracteres especiales del alfabeto inglés.

A continuación te mostramos un mini proyecto basado en ejemplo de la librería, con el cual podrás implementar cualquier arreglo de estos displays y desplegar texto en ellos, el código está modificado para la presentación de los 4 displays consecutivos, sin embargo, puede ser utilizado para la presentación de un solo display sólo poniendo y quitando algunos comentarios marcados.

Esquema de  conexión Arduino UNO





Las conexiones también se encuentran señaladas en el código.

Código Arduino

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Max72xxPanel.h>

//Vcc - Vcc
//Gnd - Gnd
//Din - Mosi (Pin 11)
//Cs  - SS (Pin 10)
//Clk - Sck (Pin 13)

const int pinCS = 10;
const int numberOfHorizontalDisplays = 4;
//const int numberOfHorizontalDisplays = 1; // retirar comentario para una sola matriz 
const int numberOfVerticalDisplays = 1;

Max72xxPanel matrix = Max72xxPanel(pinCS, numberOfHorizontalDisplays, numberOfVerticalDisplays);

String tape = "Arca Electronica";  //tu mensaje

const int wait = 100; // In milliseconds

const int spacer = 1;
const int width = 5 + spacer; // The font width is 5 pixels

void setup() {
   matrix.setIntensity(7); // Use a value between 0 and 15 for brightness

   //
   matrix.setPosition(0, 0, 0); // The first display is at <0, 0>
   matrix.setPosition(1, 1, 0); // The second display is at <1, 0>
   matrix.setPosition(2, 2, 0); // The third display is at <2, 0>
   matrix.setPosition(3, 3, 0); // And the last display is at <3, 0>

   matrix.setRotation(0, 1);    // Display is position upside down
   matrix.setRotation(1, 1);    // Display is position upside down
   matrix.setRotation(2, 1);    // Display is position upside down
   matrix.setRotation(3, 1);    // Display is position upside down

/* // retirar comentario a esto y comentar lo de arriba para una sola matriz
   matrix.setPosition(0, 0, 0); // The first display is at <0, 0>
   matrix.setRotation(0, 1);    // Display is position upside down
*/
}

void loop() {
   for (int i = 0; i < width * tape.length() + matrix.width() - 1 - spacer; i++) {

      matrix.fillScreen(LOW);

      int letter = i / width;
      int x = (matrix.width() - 1) - i % width;
      int y = (matrix.height() - 8) / 2; // center the text vertically

      while (x + width - spacer >= 0 && letter >= 0) {
         if (letter < tape.length()) {
            matrix.drawChar(x, y, tape[letter], HIGH, LOW, 1);
         }

         letter--;
         x -= width;
      }
      matrix.write(); // Send bitmap to display

      delay(wait);
   }
}

Una ves subido el código y realizadas las conexiones, verás el mensaje desplazarse de derecha a izquierda en la pantalla.


FIN DEL POST

martes, 27 de marzo de 2018

Teclados matriciales 4X4 membrana, 4X1 membrana y 4X3 rígido



Los teclados matriciales son una magnífica adición para nuestros proyectos ya que nos permitirán ingresar datos de forma directa a nuestros programas. Los teclados de membrana tienen la ventaja adicional que son adhesivos, por lo tanto pueden ser pegados al equipo donde se necesiten, el último debe ser fijado por otro método, pero es más resistente al uso.

La implementación de estos sensores la realizaremos por medio de la librería Keypad, la cual puedes descargar aquíaunque en realidad el funcionamiento de estos teclados es bastante simple, tenemos líneas de filas y líneas de columnas, luego, cuando se sense continuidad entre una fila específica y una columna específica, significa que la tecla correspondiente se ha presionado. La mayor utilidad de la librería consiste en que nos provee funciones como: de-codificación inmediata de la tecla presionada, función de tecla presionada, tiempo de presión, sensado de múltiples teclas al tiempo, entre otras.

A continuación te presentamos un mini proyecto basado en el ejemplo de la librería (la cual hemos modificado para funcione sin problemas en estos teclados), que  nos despliega la tecla presionada en el monitor serial de Arduino, con esto podrás realizar pruebas a tus teclados.

Esquema de conexión Arduino UNO





La conexión para lo otros teclados es exactamente igual, pero comenzando desde el pin 6 has el pin 2 para el teclado 4X1 y del pin 9 al pin 3 para el teclado 4X3


Código Arduino

// Si estás usando los teclados 4X1 ó 4X3 debes quitar los comentarios y eliminar lo demás, según corresponda

#include <Keypad.h>

const byte ROWS = 4; //número de filas
const byte COLS = 4; //número de columnas

// mapeo de las teclas
char hexaKeys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

byte colPins[COLS] = {5, 4, 3, 2}; //pines de columnas
byte rowPins[ROWS] = {9, 8, 7, 6}; //pines de filas

/*//quitar comentario para el teclado membrana 4X1
const byte ROWS = 1;
const byte COLS = 4;
char hexaKeys[ROWS][COLS] = {
  {'1', '2', '3', '4'},
};
byte rowPins[ROWS] = {2};
byte colPins[COLS] = {4, 3, 6, 5};
*/

/*//quitarcomentario para el teclado matricial 4X3
const byte ROWS = 4; //número de filas
const byte COLS = 3; //número de columnas
char hexaKeys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte colPins[COLS] = {5, 4, 3}; //connect to the row pinouts of the keypad
byte rowPins[ROWS] = {9, 8, 7, 6}; //connect to the column pinouts of the keypad
*/

//inicializamos el teclado
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

void setup(){
  Serial.begin(9600); // com serial
}

void loop(){
  //leemos la tecla presionada
  char customKey = customKeypad.getKey();

  if (customKey){
    Serial.println(customKey); // la desplegamos
  }
}


Una vez subido el código y realizadas las conexiones, podrás ver en el puerto serial del IDE de Arduino la tecla que presiones.


FIN DEL POST

Módulo RF 315MHz receptor YK04 y emisor



El módulo  RF YK04 es un circuito conformado por un circuito integrado decodificador junto a todos los componentes necesarios para su funcionamiento, el cual es capaz de recibir comandos desde un control remoto que podremos ubicar a una distancia de hasta 100 metros (dependiendo la antena que utilicemos). Debido a la gran sencillez en su  funcionamiento encontrarás que este conjunto de emisor y receptor por radio frecuencia nos facilitará en gran manera la aplicación de un control remoto a todos nuestros proyectos.

El funcionamiento, como ya se dijo, es bastante simple. Una vez realizadas todas las conexiones pertinentes, todas las salidas del receptor estarán en nivel bajo y al presionar cualquier letra en el emisor se pondrá en alto el pin VT (valid transmission/transmisión válida) y el pin correspondiente a la tecla presionada, siendo el D0 para la "A", D1 para "B", D2 para "C" y D3 para "D", la salida se mantendrá en alto mientras se mantenga presionado el botón en el control remoto, luego de esto, volverá a su estado inicial bajo. Con esta salida digital podrás ser capaz de activar cargas o luces (activar, no alimentar), las posibilidades son casi ilimitadas.

Las conexiones del módulo son las siguientes:

VT        Transmisión válida
D0         Salida digital
D1         Salida digital
D2         Salida digital
D3         Salida digital
GND     Referencia negativa
5V        Alimentación

A continuación te presentamos un sencillo proyecto de aplicación con el que podrás ver la tecla presionada en el control remoto desde el puerto serial.

Esquema de conexión




Código Arduino

int VT, D0, D1, D2, D3;

void setup() {
  Serial.begin(9600);
  pinMode(VT, INPUT);
  pinMode(D0, INPUT);
  pinMode(D1, INPUT);
  pinMode(D2, INPUT);
  pinMode(D3, INPUT);
}

void loop() {

  if (digitalRead(VT)) {
    Serial.print("Transmisión Válida");

    if (digitalRead(D0)) {
      Serial.print("   ");
      Serial.println("Presionada tecla A");
    }

    if (digitalRead(D1)) {
      Serial.print("   ");
      Serial.println("Presionada tecla B");
    }

    if (digitalRead(D2)) {
      Serial.print("   ");
      Serial.println("Presionada tecla C");
    }

    if (digitalRead(D3)) {
      Serial.print("   ");
      Serial.print("Presionada tecla D");
    }
  }
}

Luego de realizar las conexiones pertinentes, podrás enviarle una señal a tu placa de Arduino con el control remoto y podrás ver la tecla presionada en el puerto serial del IDE Arduino.


FIN DEL POST

lunes, 26 de marzo de 2018

Módulo shield pantalla LCD TFT LCD 2.4'' Arduino




Este  módulo  consta de una pantalla LCD que nos permitirá desplegar imágenes y agregar funciones de visualización a nuestros proyectos con Arduino. El módulo está diseñado como un shield para ser montado sobre tu placa de Arduino de tal suerte que son poco probables los errores en la conexión y cuenta también con un espacio para instalar una memoria micro SD, desde la cual podrás leer imágenes y desplegarlas también en la pantalla.

Esta módulo LCD puede presentarse con diferentes chips controladores (9320, 9325, 9341,etc.), para los cuales te verás obligado a usar diferentes librerías, este tutorial se centra en las pantallas con chips 9320 y 9325 disponibles en nuestra tienda, para las cuales te facilitamos la descarga de la librería.

Una vez descargada e instalada la librería, podrás usarla para controlar tu pantalla. A continuación te presentamos un pequeño proyecto basado en el ejemplo de la librería, donde luego de calibrar el touch de la pantalla por medio de la librería Touch, que también debes instalar, usamos la pantalla como un tablero de dibujo.

Esquema de conexión

Sólo monta el shield sobre tu placa, es muy simple! 




Código Arduino

#include <Adafruit_GFX.h> 
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft; 
#include <TouchScreen.h>

#if defined(__SAM3X8E__)
#undef __FlashStringHelper::F(string_literal)
#define F(string_literal) string_literal
#endif

uint8_t YP = A2; 
uint8_t XM = A1;
uint8_t YM = 6;
uint8_t XP = 7;
uint8_t SwapXY = 0;

uint16_t TS_LEFT = 137;
uint16_t TS_RT  = 902;
uint16_t TS_TOP = 134;
uint16_t TS_BOT = 941;

char *name = "Unknown controller";

TouchScreen ts = TouchScreen(XM, YM, XP, YP, 400);// el último numero es la resistencia entre los pines A1 y 7
TSPoint tp;                                       // puedes medir y modificar para más precisión

#define MINPRESSURE 20
#define MAXPRESSURE 1000

#define SWAP(a, b) {uint16_t tmp = a; a = b; b = tmp;}

int16_t BOXSIZE;
int16_t PENRADIUS = 3;
uint16_t identifier, oldcolor, currentcolor;
uint8_t Orientation = 0;    // Orientación vertical


#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF


void setup(void)
{
    uint16_t tmp;
    Serial.begin(9600);

    tft.reset();
    identifier = tft.readID();

    if (identifier == 0x9320) {
        name = "ILI9320";
        TS_LEFT = 137; TS_RT = 902; TS_TOP = 134; TS_BOT = 941;
    } else if (identifier == 0x9325) {
        name = "ILI9325";
        TS_LEFT = 201; TS_RT = 871; TS_TOP = 168; TS_BOT = 897;
    } else {
        name = "unknown";
    }
    
    Serial.begin(9600);
    ts = TouchScreen(XP, YP, XM, YM, 400); 
    tft.begin(identifier);
    tft.setRotation(Orientation);
    tft.fillScreen(BLACK);
    BOXSIZE = tft.width() / 6;
    tft.fillScreen(BLACK);

    tft.fillRect(0, 0, BOXSIZE, BOXSIZE, RED);
    tft.fillRect(BOXSIZE, 0, BOXSIZE, BOXSIZE, YELLOW);
    tft.fillRect(BOXSIZE * 2, 0, BOXSIZE, BOXSIZE, GREEN);
    tft.fillRect(BOXSIZE * 3, 0, BOXSIZE, BOXSIZE, CYAN);
    tft.fillRect(BOXSIZE * 4, 0, BOXSIZE, BOXSIZE, BLUE);
    tft.fillRect(BOXSIZE * 5, 0, BOXSIZE, BOXSIZE, MAGENTA);

    tft.drawRect(0, 0, BOXSIZE, BOXSIZE, WHITE);
    currentcolor = RED;
    delay(1000);
}

void loop()
{
    uint16_t xpos, ypos;
    tp = ts.getPoint();

    pinMode(XM, OUTPUT);
    pinMode(YP, OUTPUT);
    pinMode(XP, OUTPUT);
    pinMode(YM, OUTPUT);

    if (tp.z > MINPRESSURE && tp.z < MAXPRESSURE) {
        if (SwapXY != (Orientation & 1)) SWAP(tp.x, tp.y);
        xpos = map(tp.x, TS_LEFT, TS_RT, 0, tft.width());
        ypos = map(tp.y, TS_TOP, TS_BOT, 0, tft.height());

        if (ypos < BOXSIZE) {    
            oldcolor = currentcolor;

            if (xpos < BOXSIZE) {
                currentcolor = RED;
                tft.drawRect(0, 0, BOXSIZE, BOXSIZE, WHITE);
            } else if (xpos < BOXSIZE * 2) {
                currentcolor = YELLOW;
                tft.drawRect(BOXSIZE, 0, BOXSIZE, BOXSIZE, WHITE);
            } else if (xpos < BOXSIZE * 3) {
                currentcolor = GREEN;
                tft.drawRect(BOXSIZE * 2, 0, BOXSIZE, BOXSIZE, WHITE);
            } else if (xpos < BOXSIZE * 4) {
                currentcolor = CYAN;
                tft.drawRect(BOXSIZE * 3, 0, BOXSIZE, BOXSIZE, WHITE);
            } else if (xpos < BOXSIZE * 5) {
                currentcolor = BLUE;
                tft.drawRect(BOXSIZE * 4, 0, BOXSIZE, BOXSIZE, WHITE);
            } else if (xpos < BOXSIZE * 6) {
                currentcolor = MAGENTA;
                tft.drawRect(BOXSIZE * 5, 0, BOXSIZE, BOXSIZE, WHITE);
            }

            if (oldcolor != currentcolor) { 
                if (oldcolor == RED) tft.fillRect(0, 0, BOXSIZE, BOXSIZE, RED);
                if (oldcolor == YELLOW) tft.fillRect(BOXSIZE, 0, BOXSIZE, BOXSIZE, YELLOW);
                if (oldcolor == GREEN) tft.fillRect(BOXSIZE * 2, 0, BOXSIZE, BOXSIZE, GREEN);
                if (oldcolor == CYAN) tft.fillRect(BOXSIZE * 3, 0, BOXSIZE, BOXSIZE, CYAN);
                if (oldcolor == BLUE) tft.fillRect(BOXSIZE * 4, 0, BOXSIZE, BOXSIZE, BLUE);
                if (oldcolor == MAGENTA) tft.fillRect(BOXSIZE * 5, 0, BOXSIZE, BOXSIZE, MAGENTA);
            }
        }
        if (((ypos - PENRADIUS) > BOXSIZE) && ((ypos + PENRADIUS) < tft.height())) {
            tft.fillCircle(xpos, ypos, PENRADIUS, currentcolor);
        }
        if (ypos > tft.height() - 10) {
            tft.fillRect(0, BOXSIZE, tft.width(), tft.height() - BOXSIZE, BLACK);
        }
    }
}

Una vez subido el código y montado el shield sobre la placa de Arduino UNO podrás dibujar sobre la pantalla, acá una foto de lo que puedes hacer utilizando la paleta de colores:




La librería trae múltiples comandos de dibujo, con los cuales serás capaz de dibujar cualquier figura de una forma relativamente fácil, puedes aprender estos comandos mirando los múltiples ejemplos de la librería, pero el principio es básicamente el mismo.



FIN DEL POST




viernes, 16 de marzo de 2018

Módulo Ethernet shield W5100 Arduino



El módulo W5100 es un shield para el Arduino UNO o Leonardo, que  te permitirá conectar tu aplicación con una red ethernet. El módulo incluye un sócalo para  conector RJ45, lo cual te permitirá realizar la conexión por medio de un cable común a tu router o switch, está basado en el chip Wiznet W5100 que provee una pila de red IP capaz de soportar protocolos TCP y UDP. 

Una de las mayores facilidades que te provee este módulo es que para utilizarlo con Arduino UNO o Leonardo, no tienes que realizar ninguna conexión particular, sólo debes montarlo encima de tu placa Arduino, conectarlo a la red y subir tu programa al microcontrolador, todo esto con la ventaja que el módulo permite que los pines de la placa Arduino pasen a través de él dejándolos disponibles para su uso encima. Sin embargo, algo muy importante a tener en cuenta es que el módulo se comunica con el microcontrolador por comunicación SPI por medio de los pines 10, 11, 12 y 13; por lo tanto esos pines no podrán ser utilizados para otros propósitos.

El módulo cuenta con los siguientes leds para indicación:


  • ON: Indica que hay alimentación
  • LINK: Indicador de enlace de red
  • 100M: Conexión de 100 Mb/s
  • RX: Indicación de recepción de datos
  • TX: Indicación de emisión de datos
A continuación te mostramos un ejemplo sencillo de un proyecto utilizando este módulo para conectar tu proyecto Arduino a tu red ethernet. En esta aplicación se verifica el estado del digital 7 y el voltaje presente en el pin digital A0. Este proyecto está basado en el análogo de "el Profe Garcia".

Estema de conexión con Arduino UNO
Modulo Ethernet Shield W5100 Arduino
Sólo monta el shield sobre tu placa!  
Y conecta el cable utp con conector RJ45 desde tu router o switch.


Código Arduino:



#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};

IPAddress ip(192, 168, 0, 52); // SÓLO EL ÚLTIMO NÚMERO DEBES CAMBIAR

EthernetServer server(80);

void setup() {
  Ethernet.begin(mac, ip);
  server.begin();
}

void loop() {
  EthernetClient client = server.available();
  if (client) {
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        if (c == '\n' && currentLineIsBlank) {
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");
          client.println("Refresh: 5");
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          client.println("<HEAD>");
          client.println("<TITLE>Ethernet Monitor</TITLE>");
          client.println("</HEAD>");
          client.println("<BODY>");
          client.println("<hr />");
          client.println("<H1>Ejemplo de uso W5100</H1>");
          client.println("<br />");
          client.println("<H2>Monitoreo de pin digital</H2>");
          client.println("<br />");
          client.println("");
          client.println("<br />");
          client.println("<br />");
          int lecturaSensor = digitalRead(7); 
          float lecturanaloga = analogRead(A0);
          client.print("Estado de Pin digital D7: ");
          client.print((lecturaSensor)?"ALTO":"BAJO");
          client.println("<br />");
          client.println(" ");
          client.println("<br />");
          client.print("Voltaje en el Pin A0: ");
          client.print(lecturanaloga*5/1023);
          client.print(" V");
          client.println("<br />");
          client.println(" ");
          client.println("<br />");
          client.println("Ma's tutoriales en nuestro blog Arca electro'nica");
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }
    delay(15);           // Da tiempo al Servidor para que reciba los datos 15ms
    client.stop();     // cierra la conexion
  }
}


Una vez subido el código, pon en la barra de direcciones de tu navegador la siguiente dirección: 192.168.0.52, presiona "Enter" y verás en tu pantalla el estado de estos dos pines, lo cuales puedes cconectar a GND, 3.3V o 5V de tu Arduino, para que compruebes su funcionamiento. 


NOTA: En caso de que haya algún error, prueba cambiando el último número de la dirección en tu navegador y en la línea señalada en el código (debe ser el mismo número).





FIN DEL POST

miércoles, 28 de febrero de 2018

Control de acceso con Módulo RFID RC522 Arduino


El módulo RFID RC522 es una placa de identificación de tags y tarjetas (lectura y escritura) por medio del estándar ISO/IEC 14443 tipo A que funciona bajo 13.56 MHz. Este módulo es extremadamente útil para proyectos de controles de acceso dándonos una gran versatilidad en los modos de encriptación de los códigos de acceso. EL módulo puede comunicarse con  un microcontrolador (una placa Arduino, por ejemplo) por medio  de comunicación SPI y por un puerto UART. los pines del módulo son los siguientes:

SDA:       Comunicación
SCK:       Comunicación
MOSI:     Comunicación
MISO:     Comunicación
IRQ:        Comunicación
GND:      Referencia Negativa
RST:        Reset
3.3V:       Voltaje de alimentación 3.3VDC máx


Con el fin de guardar tu clave de acceso, puedes usar  un algoritmo tan complejo como quieras, incluso existen algoritmos especializados (dependiendo de la aplicación) que te permiten "ocular" la clave de  una forma específica dentro del 1Kb de memoria que traen la mayoría de los tags y tarjetas, con el fin de dificultar el hacking; sin embargo, si tu  aplicación es  muy simple y más bien domestica, no deberías complicarte la vida con estas cosas y podrías sólo utilizar el serial (único para cada tag y tarjeta) de la siguiente manera: 

1. Leer el serial del dispositivo presente.
2. Compararlo con el serial guardado.
3. Y si  es el mismo, entonces es tu tarjeta y permite el acceso, de  lo contrario, no. 

Es esto precisamente lo que hacemos en el sencillo proyecto que te mostramos a continuación como un buen ejemplo de aplicación:

Control de Acceso simple con RC522 y Arduino UNO


Este proyecto te permitirá activar o desactivar un relevo por medio de la identificación de un tag o tarjeta específico que puede ser cambiado fácilmente en sólo 3 pasos: 

1. Conectar pin 3 al negativo
2. Ubicar el nuevo dispositivo en el sensor 
3. Retirar la conexión al negativo. 

Al colocar la tarjeta o tag correcto, el buzzer y el relevo serán activados por 2 segundos, en el relevo podrás conectar un seguro eléctrico de puerta o lo que desees activar con el RFID.

Si quieres utilizar más de un dispositivo de acceso, deberás modificar el código y agregar la verificación de tantas claves como tags o tarjetas uses, el proyecto usa la librería MFRC522 de autoría de la comunidad de Github.

Esquema de conexión 




Código Arduino:



#include <EEPROM.h> // incluimos librerías  

#include <SPI.h>

#include <MFRC522.h>



#define SS_PIN 10
#define RST_PIN 9

MFRC522 mfrc522(SS_PIN, RST_PIN);// instanciamos el módulo

// pines
int BuzzPin = 7;
int LoadPin = 6;
int nueva = 3;
// variables
int y;

// rutina para imprimir el serial en el puerto serie
void printDec(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], DEC);
  }
  Serial.println();
}

// rutina que compara los seriales
boolean comparar(byte *buffer) {

  boolean x;

  if (buffer[0] == EEPROM.read(0)) {
    if (buffer[1] == EEPROM.read(1)) {
      if (buffer[2] == EEPROM.read(2)) {
        if (buffer[3] == EEPROM.read(3)) {
          if (buffer[4] == EEPROM.read(4)) {
            if (buffer[5] == EEPROM.read(5)) {
              x = true;
            }
          }
        }
      }
    }
  }
  else {
    x = false;
  }
  return x;
}

// rutina que guarda el serial nuevo
void guardar(byte *buffer) {
  EEPROM.write(0, buffer[0]);
  EEPROM.write(1, buffer[1]);
  EEPROM.write(2, buffer[2]);
  EEPROM.write(3, buffer[3]);
  EEPROM.write(4, buffer[4]);
  EEPROM.write(5, buffer[5]);
  Serial.println("Guardado corrrectamente");
}


void setup() {

  Serial.begin(9600); // inicializamos la comunicación serial
  SPI.begin();        // inicializamos la comunicación spi
  mfrc522.PCD_Init(); // inicializamos el módulo
  pinMode(BuzzPin, OUTPUT); // salidas
  pinMode(LoadPin, OUTPUT);
  pinMode(nueva, INPUT_PULLUP); // entrada
  digitalWrite(BuzzPin, LOW); //  valores iniciales
  digitalWrite(LoadPin, HIGH);
  y = 0;
}

void loop() {

  byte buffer[18];
  byte size = sizeof(buffer);

  // busca si hay un tag
  if ( ! mfrc522.PICC_IsNewCardPresent()) {
    Serial.println("No hay tarjeta"); // sino lo hay, dice que no ay tarjeta
  }
  else {
    // en caso de que haya un tag, se verifica si no se desea guardar ese tag
    if ((digitalRead(nueva) == LOW) && (y == 0)) {
      mfrc522.PICC_ReadCardSerial();
      guardar(mfrc522.uid.uidByte); // función para guardar
      y = 1; // de esta fora sólo se guarda ua vez
    }
    else {
      Serial.println("Se detetecta una tarjeta");
      Serial.println();
      Serial.println("Serial de la tarjeta ...");
      mfrc522.PICC_ReadCardSerial(); // funccion que lee el serial
      printDec(mfrc522.uid.uidByte, mfrc522.uid.size); //Se imprime en el puerto serial
      if (comparar(mfrc522.uid.uidByte)) { // se compara con el serial guaardado
        digitalWrite(BuzzPin, HIGH); // si es el correcto se desbloquea el sistema
        digitalWrite(LoadPin, LOW);
        Serial.println("desbloqueado");
        delay(2000);// por 2 segundos
        digitalWrite(BuzzPin, LOW);
        digitalWrite(LoadPin, HIGH); // luego se vuelve a bloquear
      }
      else {
        digitalWrite(BuzzPin, LOW); // si es incorrecto, permanece bloqueado.
        digitalWrite(LoadPin, HIGH);
        Serial.println("tarjeta invalida"); // y en el puerto serial se muestra mensaje
        Serial.println();
      }
      delay(500);
    }
  }
}


Al subir el código a tu Arduino y realizar las conexiones, podrás ver en el puerto serial del IDE de Arduino, el estado del sistema.

NOTA: El nivel de seguridad de este este proyecto es muy bajo y no debe ser utilizado en aplicaciones muy delicadas, pues podría hackearse con facilidad:  


FIN DEL POST

jueves, 22 de febrero de 2018

Módulo relé y control remoto universal 433Mhz





Este módulo consiste de un relé de 12V que puede ser controlado a distancia por medio  de un sencillo control remoto que funciona a frecuencia de 433MHz. Útil para controlar cargas a distancia en lugares de difícil acceso. El sistema cuenta con 3 modos de operación detallados más adelante:

Alimentación: 12 VDC
Corriente: 40 mA
Voltaje de la carga (AC): 110/240 VAC
Voltaje de la carga (DC): 30 VDC
Corriente mámixa: 10A
Distancia máx de accionamiento: 30 m




Configuración inicial del control remoto

1. Alimente el módulo receptor
2. Presione el botón de modo del selector
3. Presione el botón del control remoto
luego de esto, una luz  indicadora parpadeará 3 veces indicando que la configuración fue guardada

Configuración de los 3 modos de operación
  • Modo 1
En este modo, al presionar el botón del control remoto, el  relevo se activará y permanecerá  así hasta que corte su alimentación. Para configurar este  modo:
1. Mantenga presionado el botón de selección de modo
2. Alimente el receptor
3. Observará una luz parpadear, al segundo parpadeo suelte el botón de modo
  •  Modo 2
En este modo, al presionar el botón del control remoto, el  relevo se activará y  al presionaarlo una segunda vez se desactivará. Para configurar este  modo:
1. Mantenga presionado el botón de selección de modo
2. Alimente el receptor
3. Observará una luz parpadear, al tercer parpadeo suelte el botón de modo
  •   Modo 3
En este modo, al presionar el botón del control remoto, el  relevo se activará y  al soltar el botón, el relevo se desactivará. Para configurar este  modo:
1. Mantenga presionado el botón de selección de modo
2. Alimente el receptor
3. Observará una luz parpadear, al cuarto parpadeo suelte el botón de modo

EJEMPLO DE CONEXIÓN

En el siguiente esquema podemos ver como conectar una carga, una luz en este caso, para ser activada remotamente:







FIN DEL POST

lunes, 19 de febrero de 2018

Control de motores a pasos con TB6600 y Arduino

Resultado de imagen para motor nema 17

 
Los  motores paso a  paso son un conjunto consistente de una caja reductora y un motor DC con una distribución especial  en sus bobinas. Esta distribución especial permite moverlos secuencialmente a medida que activamos y desactivamos cada bobina de una forma específica. Cada  modelo de motor paso a paso requiere una cantidad específica de pasos para dar  una vuelta completa, la cantidad  puedes encontrarla en el datasheet del motor. Cabe destacar también que, a diferencia de los servomotores, un motor paso a paso no tiene un sistema de retroalimentación para su posición, de esta forma, si  por ejemplo una fuerza externa lo mueve del de su set point, éste no será capaz de volver a tal posición. 

Por otro lado, a la hora de conectar un motor paso a paso debemos identificar primero el tipo de motor, sea unipolar (más de 4 cables) o bipolar (4 cables). Una vez identifiques el tipo de motor, debes identificar las conexiones de las bobinas, esto puedes hacerlo con un multímetro, este proceso consiste simplemente en medir continuidad.

Finalmente, para mover un motor paso a paso, como ya se dijo, es necesario activar sus bobinas en una secuencia específica, por lo tanto se hace necesario programar en un microcontrolador la  secuencia de pasos requerida. Sin embargo, existe una forma de simplificar esto, por medio del TB6600. Este es un circuito electrónico que es capaz de proveer la secuencia de  pasos que necesita el motor dándole nosotros sólo 2 señales básicamente, la primera es una señal digital que indique la dirección del movimiento (izquierda o derecha, alto o bajo) y la segunda, un flanco de subida cada vez que deseemos que el  motor de un paso. 

Una vez identifiquemos  el tipo de motor, debemos conectarlo al TB6600. Para este fin, a continuación listamos las conexiones más importantes del Easydriver por grupo.

Para conectar a nuestro microcontrolador tenemos:


+5V = Referencia de voltaje
CLK = Señal de avance, debemos enviar aquí un flanco de subida cada vez que queremos  que el motor avance un paso.
CW = Señal de dirección, debemos poner aquí un alto o un bajo según  si queremos que el  motor avance en una dirección o otra.
EN = Señal para habilitar y deshabilitar el movimiento del motor, puede dejarse sin conectar

Para conectar a la fuente para el motor tenemos: 


+32V = Positivo de la  fuente, de 8 a 42 VDC

GND = Referencia negativa de la fuente

Para conectar a nuestro motor tenemos 4 conexiones, 2 marcadas como A y 2 marcadas  como B, aquí debes conectar los extremos de las bobinas según se ha identificado previamente. Si es un motor bipolar, esta conexión es bastante obvia, sin embargo, si es un motor unipolar, deberás identificar cuales son los extremos  de las bobinas (serán los cables con mayor resistencia entre sí) y dejar los demás cables sin conectar (sólo conectas 4).


También debes tener en cuenta el potenciómetro del TB6600, debes ubicar éste para que sea capaz de suplir toda la corriente que necesita tu motor paso a paso, el TB6600 es capaz de suplir hasta 4 A por fase. Por último, debes revisar los switches de modo paso, hay 4 sobre la placa, pero en realidad sólo el 1, el 2 y el 3 tienen conexión. A continuación te mostramos los modos de operación según la posición de estos switches:


M1M2M3Modo seleccionado
OFFOFFOFFSTAND BY
OFFOFFONFULL STEP
OFFONOFF1/2 STEP A
OFFONON1/2 STEP B
ONOFFOFF1/4 STEP
ONOFFON1/8 STEP
ONONOFF1/16 STEP
ONONONSTAND BY




Ejemplo de operación de motor paso a paso con TB6600

Al realizar el siguiente montaje y subir el código a tu Arduino, observarás al motor moverse en una dirección y luego en otra. Si el motor es de 200 o menos pasos por unidad, dará una vuelta completa teniendo al driver en modo FULLSTEP.

Empezamos mostrando un esquema de conexión con Arduino UNO:







Código Arduino

int Dir = 13; //  definimos el pin de dirección CW
int Step = 12; // definimos el pin de comando de pasos CLK
boolean state  = true;


void setup() {

pinMode(Step,OUTPUT); // seleccionamos ambos pines como salidas
pinMode(Dir,OUTPUT);
digitalWrite(Step, LOW); //  escribimos valores iniciales
digitalWrite(Dir, LOW);

}

void loop() {

  state = !state; // luego de cada ciclo, cambiamos el estado para cambiar la dirección

  digitalWrite(Dir,state);  

  for (int i = 0; i < 200 ; i++)  // en este ciclo damos 200 pasos
  {    
    digitalWrite(Step, HIGH);
    delay(10);
    digitalWrite(Step, LOW);
    delay(10);
  }

}


FIN DE POST

Display matricial 8x8 con Arduino SPI y MAX7219

La matrices led de 8x8 son elementos extremadamente útiles para desplegar mensajes que puedan ser visibles desde la distancia. ...