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

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. ...