El Módulo Lector RFID-RC522 RF utiliza 3.3V como voltaje de alimentación y se controla a través del protocolo SPI o UART. Es compatible con casi cualquier micro controlador, Arduino o tarjeta de desarrollo. El RC522 utiliza un sistema avanzado de modulación y de-modulación para todo tipo de dispositivos pasivos de 13.56Mhz. Como se hará una lectura y escritura de la tarjeta, es necesario conocer las características de los bloques de memoria una tarjeta. La tarjeta que viene con el módulo RFID cuenta con 64 bloques de memoria (0-63) donde se hace lectura y/o escritura. Cada bloque de memoria tiene la capacidad de almacenar hasta 16 Bytes. El número de serie consiste de 5 valores hexadecimales, se podría utilizar esto para hacer una operación dependiendo del número de serie.

Características del Módulo Lector RFID-RC522 RF

• Modelo: MF522-ED
• Corriente de operación: 13-26mA a 3.3V
• Corriente de stand by: 10-13mA a 3.3V
• Corriente de sleep-mode: <80uA
• Corriente máxima: 30mA
• Frecuencia de operación: 13.56Mhz
• Distancia de lectura: 0 a 60mm
• Protocolo de comunicación: SPI
• Velocidad de datos máxima: 10Mbit/s
• Dimensiones: 40 x 60 mm
• Temperatura de operación: -20 a 80ºC
• Humedad de operación: 5%-95%
• Máxima velocidad de SPI: 10Mbit/s
• Incluye pines, llavero y tarjeta

DESCRIPCIÓN del ejemplo

Se hara uso del Arduino UNO y el Módulo Lector RFID-RC522 RF para escribir sobre la tarjeta o llavero y ejecutaremos un programa el cual leerá la información escrita.

MATERIALES

• Módulo Lector RFID-RC522 RF y tarjeta.
• 1 Arduino Uno.
• Cables jumper macho a macho.
• Protoboard.

CONEXIÓN Módulo Lector RFID-RC522 RF con arduino

Diagrama de conexión del RFID-RC522 RF con Arduino

Biblioteca

Link de descargar de librerías :
https://github.com/miguelbalboa/rfid

Como instalar bibliotecas: https://www.arduino.cc/en/Guide/Libraries

Código para escribir en la tarjeta/llavero

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN 9 // Configurable, see typical pin layout above
#define SS_PIN 10 // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance

void setup() {
Serial.begin(9600); // Initialize serial communications with the PC
SPI.begin(); // Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card
Serial.println(F("Ingrese Tarjeta para Escribir Dato Personal"));
}

void loop() {

// Prepare key - all keys are set to FFFFFFFFFFFFh at chip delivery from the factory.
MFRC522::MIFARE_Key key;
for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF;

// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}

// Select one of the cards
if ( ! mfrc522.PICC_ReadCardSerial()) return;

Serial.print(F("Num. de Serie unico:")); //Dump UID
for (byte i = 0; i < mfrc522.uid.size; i++) {
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
}
Serial.print(F(" PICC type: ")); // Dump PICC type
MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
Serial.println(mfrc522.PICC_GetTypeName(piccType));

byte buffer[34];
byte block;
MFRC522::StatusCode status;
byte len;

Serial.setTimeout(20000L) ; // wait until 20 seconds for input from serial

// Ask personal data: First name
Serial.println(F("Escriba Dato, al final incluya #"));
len=Serial.readBytesUntil('#', (char *) buffer, 20) ; // read first name from serial
for (byte i = len; i < 20; i++) buffer[i] = ' '; // pad with spaces

block = 6; //Se especifica en que bloque se escribira _____------______-----______

//Serial.println(F("Authenticating using key A..."));
status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid));
if (status != MFRC522::STATUS_OK) {
Serial.print(F("PCD_Authenticate() failed: "));
Serial.println(mfrc522.GetStatusCodeName(status));
return;
}

// Write block
status = mfrc522.MIFARE_Write(block, buffer, 16);
if (status != MFRC522::STATUS_OK) {
Serial.print(F("MIFARE_Write() failed: "));
Serial.println(mfrc522.GetStatusCodeName(status));
return;
}
else Serial.println(F("MIFARE_Write() Escritura Realizada Corectamente: "));

block = 5;
//Serial.println(F("Authenticating using key A..."));
status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid));
if (status != MFRC522::STATUS_OK) {
Serial.print(F("PCD_Authenticate() failed: "));
Serial.println(mfrc522.GetStatusCodeName(status));
return;
}

// Write block
status = mfrc522.MIFARE_Write(block, &buffer[16], 16);
if (status != MFRC522::STATUS_OK) {
Serial.print(F("MIFARE_Write() failed: "));
Serial.println(mfrc522.GetStatusCodeName(status));
return;
}
else Serial.println(F("MIFARE_Write() Escritura Realizada Corectamente: "));
Serial.println(" ");
mfrc522.PICC_HaltA(); // Halt PICC
mfrc522.PCD_StopCrypto1(); // Stop encryption on PCD

}

Aspectos del programa de escritura

Se agregan las librerías

#include <SPI.h>

#include <MFRC522.h>

Esta línea específica que se tendrán 20s para poder escribir el dado a grabar en la tarjeta/llavero

Serial.setTimeout(20000L) ;     // wait until 20 seconds for input from serial

Al ingresar el dato a escribir se tendrá que ingresar “#” al final para confirmar el dato
En nuestro caso se grabo fue:
HETPRO RFID-RC522, por lo cual se ingresó en el monitor serial: HETPRO RFID-RC522#
NOTA: recuerda que la capacidad por bloque es de 16 Bytes = 16 caracteres

Serial.println(F("Escriba Dato, al final incluya #"));
len=Serial.readBytesUntil('#', (char *) buffer, 20) ; // read first name from serial
for (byte i = len; i < 20; i++) buffer[i] = ' '; // pad with spaces

Se especifica cual será el bloque en el que escribirá

block = 6; //Se especifica en que bloque se escribira

Al abrir el monitor serial lo primero que aparecerá será el mensaje de “Ingrese Tarjeta para Escribir Dato Personal”
Una vez colocada la tarjeta aparecerá su núm. De serie único y su PICC type, ademas del mensaje «Escriba Dato, al final incluya #»
Entonces tendrá 20s para agregar el dato a escribir
Si se escribió correctamente aparecerá el mensaje
MIFARE_Write() Escritura Realizada Corectamente:
MIFARE_Write() Escritura Realizada Corectamente:

Una vez realizado esto el dato quedara escrito en la tarjeta/llavero.
Para poder hacer lectura de este dato usaremos el siguiente programa

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN 9 // Configurable, see typical pin layout above
#define SS_PIN 10 // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.

MFRC522::MIFARE_Key key;

/**
* Initialize.
*/
void setup() {
Serial.begin(9600); // Initialize serial communications with the PC
while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
SPI.begin(); // Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card

// using FFFFFFFFFFFFh which is the default at chip delivery from the factory
for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF;
}

Serial.println(F("Ingrese Tarjeta"));
}

/**
* Main loop.
*/
void loop() {
// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent())
return;

// Select one of the cards
if ( ! mfrc522.PICC_ReadCardSerial())
return;

byte sector = 1;
byte blockAddr = 6; //Se especifica que bloque se leera _____------______-----______
byte dataBlock[] = {
0x01, 0x02, 0x03, 0x04, // 1, 2, 3, 4,
0x05, 0x06, 0x07, 0x08, // 5, 6, 7, 8,
0x08, 0x09, 0xff, 0x0b, // 9, 10, 255, 12,
0x0c, 0x0d, 0x0e, 0x0f // 13, 14, 15, 16
};
byte trailerBlock = 7;
MFRC522::StatusCode status;
byte buffer[18];
byte size = sizeof(buffer);

Serial.println(F("Datos actuales en el sector:"));
mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector);
Serial.println();

// Read data from the block
Serial.print(F("Cargando dato del bloque ")); Serial.print(blockAddr);
Serial.println(F(" ..."));
status = (MFRC522::StatusCode) mfrc522.MIFARE_Read(blockAddr, buffer, &size);
if (status != MFRC522::STATUS_OK) {
Serial.print(F("MIFARE_Read() failed: "));
Serial.println(mfrc522.GetStatusCodeName(status));
}
Serial.print(F("Dato en el bloque ")); Serial.print(blockAddr); Serial.println(F(":"));
dump_byte_array(buffer, 16); Serial.println();
Serial.println();

}

/**
* Helper routine to dump a byte array as hex values to Serial.
*/
void dump_byte_array(byte *buffer, byte bufferSize) {
for (byte i = 0; i < bufferSize; i++) {
// Serial.print(buffer[i] < 0x10 ? " 0" : " ");
// Serial.print(buffer[i], HEX);

Serial.write(buffer[i]);

}
}

Aspectos del programa lectura

Agregar librerías

#include <SPI.h>

#include <MFRC522.h>

Se especifica el sector y bloque que se leerá
Nota:Este debe coincidir con el bloque en que se escribió en el primer programa, o simplemente con el bloque que se desee leer

byte sector         = 1;
byte blockAddr      = 6; //Se especifica  que bloque se leera _____------______-----______

Es importante recalcar que los datos escritos en la tarjeta/llavero siempre serán en hexadecimal, por lo cual para su lectura es importante hacer la conversión de HEX a ASCII

Serial.write(buffer[i]);

Al ejecutar el programa aparecerá el mensaje “Ingrese Tarjeta”
Una vez colocada la tarjeta aparecerá los “Datos actuales en el sector”, esto te permitirá ver que bloques están disponibles para escribir en ellos, además de ver si hay algo ya escrito en otro bloque
Nota: se puede sobrescribir en el bloque en el cual ya escribiste, así que si quiere cambiar lo escrito por algún error o por algún otro motivo puedes hacer.
En el primer bloque no se puede escribir, en nuestro caso el bloque 7
Después aparece
Cargando el dato del bloque “se imprime el número del bloque que se leerá”
Dato en el bloque “se imprime el número del bloque que se leerá”
“Se imprime dato escrito en la tarjeta/llavero”

La entrada Módulo RFID-RC522 Escritura aparece primero en Cuantex - Hardware Libre en México.

Un actuador lineal es un dispositivo que convierte el movimiento de rotación de un motor de corriente directa en movimiento lineal, es decir, movimientos de empuje y halado. Este dispositivo permite el empuje de objetos pesados con tan solo presionar un botón.

Otra ventaja que ofrece un actuador lineal es la seguridad, movimientos silencioso, limpio de control preciso. Son muy eficientes de larga vida con poco o ningún mantenimiento.

Objetivo

En este tutorial vamos a controlar un Actuador con un Smartphone por medio de comunicación Bluetooth y la Tarjeta Interfaz de potencia para Arduino Pro-mini / Pro-micro. Para poder controlar el Actuador lineal debemos interconectar los 4 relevadores que tiene la tarjeta interfaz de potencia como un puente H, ya que el Actuador se controla como un Motor de corriente directa y el puente H nos permitirá hacer los cambios de polarización para que el vástago del actuador se desplace hacia afuera o adentro.

MATERIAL

• Tarjeta Interfaz de potencia para Arduino Pro-mini / Pro-micro RSPA0002.
• Actuador de 18 pulgadas.
• Fuente de 12VDC( Por lo menos de 3 A).
• Eliminador 9VDC.
• Módulo Bluetooth HC-06.
• Smartphone.

DIAGRAMA DE CONEXIONES

Diagrama de conexiones de RSPA0002 con Bluetooth y Actuador Lineal

IMÁGENES

CÓDIGO

/*Tutoriales Cuantex*/
/*Actuador Lineal controlado por Bluetooth y RSPA0002*/
/*WWW.CUANTEX.COM*/

//se Asigna un nombre a cada pin para identificar cual Relevador sera controlado
int Relay1 = 10;
int Relay2 = 16;
int Relay3 = 14;
int Relay4 = 15;
int Direc = 0;
//int Solid1 = 9;
//int Solid2 = 8;
 
void setup()
{
/*Inicializaciòn de Serial para Arduino Pro micro*/
/*Para conectar Bluetoot, inicializar como: Serial1.begin()*/
  Serial1.begin(9600);
  while (!Serial1) {}
  //Se definen los pines como salidas para el control de los Relevadores
 pinMode(Relay1, OUTPUT);
 pinMode(Relay4, OUTPUT);
 
 pinMode(Relay2, OUTPUT);
 pinMode(Relay3, OUTPUT);
}
 
void loop()
{
  if (Serial1.available() > 0)
    {
      Direc = Serial1.read();
        switch(Direc)
          {
/*Mover Actuador lineal hacia afuera*/
      case 'a':
 digitalWrite(Relay1, HIGH);
 digitalWrite(Relay4, HIGH);
 digitalWrite(Relay2, LOW);
 digitalWrite(Relay3, LOW);
 break;
/*Mover Actuador lineal hacia adentro*/
      case 'b':
 digitalWrite(Relay2, HIGH);
 digitalWrite(Relay3, HIGH);
 digitalWrite(Relay1, LOW);
 digitalWrite(Relay4, LOW);
 break;
 
          }//SwitchCase
    }//Serial1Available
}//end loop()

ENLACES DE INTERÉS

video: https://www.youtube.com/watch?v=m9qJ-TJlPyw

La entrada Actuador lineal controlado por Bluetooth aparece primero en Cuantex - Hardware Libre en México.

Contador 7 Segmentos Cuantex

Contador 7 Segmentos Cuantex

Para este proyecto vamos a necesitar el Contador 7 Segmentos Cuantex, un Arduino y ya sea un juego de jumpers Hembra-Macho, o un protoboard con juego de jumpers Macho-Macho, y la practica es realizar un contador de 0 a 9 y posterior de 0 a 99.

La estructura del Display, Contador 7 Segmentos Cuantex:

Contador 7 Segmentos «Cuantex», Estructura.

Contador 0 a 9 7 Segmentos Cuantex

Como se puede apreciar mas adelante el programa consta de 3 secciones, al pasarlo al ID de Arduino van uno seguido el otro.

Sección 1:

Se declaran las 2 Salidas de control y las 7 Salidas de A,B,C,D,E,F,G correspondientes a los 7 Segmentos, Contador 7 Segmentos Cuantex.

nota: se evitan los pines 0 y 1 por la comunicación Serial TX,RX.

void setup() {
   Serial.begin(9600);
   pinMode(10, OUTPUT);
   pinMode(9, OUTPUT);
   pinMode(8, OUTPUT);
   pinMode(7, OUTPUT);
   pinMode(6, OUTPUT);
   pinMode(5, OUTPUT);
   pinMode(4, OUTPUT);
   pinMode(3, OUTPUT);
   pinMode(2, OUTPUT);
}

// Función del display
void display (int A, int B, int C, 
       int D, int E, int F, int G)
{
   digitalWrite (10,A); 
   digitalWrite (9,B); 
   digitalWrite (8,C); 
   digitalWrite (7,D);
   digitalWrite (6,E);
   digitalWrite (5,F);
   digitalWrite (4,G);
 delay(10); 
}

Contador 7 Segmentos «Cuantex», estructura. Fuente: https://2.bp.blogspot.com/-9arg5_6mFO0/VTWXTv9htSI/AAAAAAAAHe0/J70HPOIHSG8/s1600/7seg1.gif

Sección 2/3:

Tenemos una Función «display(0,0,0,0,0,0,0)» 7 segmentos. 0 —> display (1,1,1,1,1,1,0); 0 sección apagada o un 8 —> display (1,1,1,1,1,1,1); 1 sección encendida

// Funicion de Numero en 7 Segmentos
void numero(int n){ 
   if (n==0){ display (1,1,1,1,1,1,0); } //0
   if (n==1){ display (0,1,1,0,0,0,0); } //1
   if (n==2){ display (1,1,0,1,1,0,1); } //2
   if (n==3){ display (1,1,1,1,0,0,1); } //3
   if (n==4){ display (0,1,1,0,0,1,1); } //4
   if (n==5){ display (1,0,1,1,0,1,1); } //5
   if (n==6){ display (1,0,1,1,1,1,1); } //6
   if (n==7){ display (1,1,1,0,0,0,0); } //7
   if (n==8){ display (1,1,1,1,1,1,1); } //8
   if (n==9){ display (1,1,1,0,0,1,1); } //9
}

Sección 3/3:

Tenemos una Función «numero(#)» para 0 a 9, así llegamos al programa general donde queremos hacer un contador 0 a 9, generamos la variable unidad inicia en «cero» y por cada turno aumenta 1, al llegar al 9 sale del while y inicia en «cero» nuevamente.

// Programa general donde hacemos un Contador de 0 a 9 
void loop(){
    pinMode(3,1); pinMode(2,0);
 
    int unidades = 0;
    while(unidades<=9){
       numero(unidades); //10+10 milis por turno
       unidades++;
       delay(290); //10+290=300
    }
    unidades = 0; 
}

NOTA:

por el momento para una sola unidad K0 es el único activo. pinMode(3,1); —> que esta activando a K0, pinMode(2,0); —> que esta des activando a K1.

CONECTANDO LOS DISPLAYS EN SERIE

Contador 0 a 99 «7 Segmentos Cuantex»

Contador 7 Segmentos «Cuantex», Cableado.

Como se puede apreciar el programa consta de 3 secciones, al pasarlo al ID de Arduino van uno seguido el otro.

Sección 1/3:

Se declaran las 2 Salidas de control y las 7 Salidas de A,B,C,D,E,F,G correspondientes a los 7 Segmentos, Contador 7 Segmentos Cuantex. La función antes vista «display (A,B,C,D,E,F,G);» y la función antes vista «numero(0-9)».

void setup() {
   Serial.begin(9600);
   pinMode(10, OUTPUT);
   pinMode(9, OUTPUT);
   pinMode(8, OUTPUT);
   pinMode(7, OUTPUT);
   pinMode(6, OUTPUT);
   pinMode(5, OUTPUT);
   pinMode(4, OUTPUT);
   pinMode(3, OUTPUT);
   pinMode(2, OUTPUT);
}

// Función del display
void display (int A, int B, int C, 
       int D, int E, int F, int G)
{
   digitalWrite (10,A); 
   digitalWrite (9,B); 
   digitalWrite (8,C); 
   digitalWrite (7,D);
   digitalWrite (6,E);
   digitalWrite (5,F);
   digitalWrite (4,G);
 delay(10); 
}

// Funicion de Numero en 7 Segmentos
void numero(int n){ 
   if (n==0){ display (1,1,1,1,1,1,0); } //0
   if (n==1){ display (0,1,1,0,0,0,0); } //1
   if (n==2){ display (1,1,0,1,1,0,1); } //2
   if (n==3){ display (1,1,1,1,0,0,1); } //3
   if (n==4){ display (0,1,1,0,0,1,1); } //4
   if (n==5){ display (1,0,1,1,0,1,1); } //5
   if (n==6){ display (1,0,1,1,1,1,1); } //6
   if (n==7){ display (1,1,1,0,0,0,0); } //7
   if (n==8){ display (1,1,1,1,1,1,1); } //8
   if (n==9){ display (1,1,1,0,0,1,1); } //9
}

Sección 2/3:

Este es el truco para switchear entre Decenas e Unidades, en la función «display» se esconde un arma secreta, delay(10); ya que el ojo humano no puede apreciar cambios de 10 milisegundos, switcheamos entre activar y desactivar los Segmentos:

// Funcion salto entre Decimal y Unidad
 void Decimal(int des, int lapso){
    int conteo=0;
    while (conteo<=lapso){
        digitalWrite (3,0); // Que esta des activando a K0,
        digitalWrite (2,1); // Que esta activando a K1,
            numero(des);      // Mostrar Decenas

        digitalWrite (3,1); // Que esta activando a K0,
        digitalWrite (2,0); // Que esta des activando a K1,
             numero(uni);     // Mostrar Unidades</pre>
<pre>        conteo++; 
    }
} 

Sección 3/3:

Haciendo uso de la Función «Decimal(decenas, unidades, 10);», así llegamos al programa general donde queremos, hacer un contador 0 a 99, asi generamos la variable unidad y decenas inicia en «cero» y por cada turno aumenta 1++; al llegar al 9 sale del while e inicia en «cero» nuevamente.

// Programa general donde hacemos un Contador de 0 a 99 
void loop(){

 int unidades = 0;
 int decenas =0;

 while (decenas<=9){
    while(unidades<=9){
       Decimal(decenas, unidades, 10); 
       //10+10 milis por turno
       unidades++;
    }
    unidades = 0;
    decenas++; 
 } 
 decenas=0;
} 

Contador 0 a 99 «7 Segmentos Cuantex»

Contador 7 Segmentos «Cuantex», Cableado.

La entrada Contador 7 Segmentos Cuantex 2 displays aparece primero en Cuantex - Hardware Libre en México.

En este tutorial se utilizara el display de 7 segmentos para secuencia de números con cada pulso que detecte el Arduino en otras palabras un contador de 0 al 9. El display de 7 segmentos esta separado en bloques que te permite crear los números o patrones que necesites e instalarlos en donde los requieras.

Materiales:

• Arduino UNO
• Display 7segmentos
• 7 Transistor 2N222
• 8 Resistencias 1Kohm
• 1 Protoboard
• Cables macho-macho
• Alambre para proto
• 1Push Button
• Fuente de 12V

Transistor como switch

Cada segmento del display de 7segmentos se alimenta con 12V lo cual es necesario hacer un arreglo con transistores que en este caso se utilizara un 2N2222 que es un NPN que actúen como switch para encender cada uno de los segmentos.

Para que un transistor actué como switch es necesario llevarlo a corte o saturación:

Corte: No hay corriente en la base por lo cual todo el voltaje cae sobre el transistor.

Saturación: tiene una corriente de colector máxima y un voltaje colector emisor casi nulo.

Transistor NPN

Registros de puertos en arduino.

Estos registros nos permiten una manipulación más rápida de los pines de E/S de nuestro Arduino. El microcontrador de esta placa tiene tres puertos:

• Puerto B:pin digital de 8-13
• Puerto C: pines de entrada analógica
• Puerto D: pines digitales 0-7

Cada uno de estos puertos está controlado por tres registros los cuales se definen por DDR, PORT y PIN.

DDR

Determina si el pin es entrada o salida.

Ejemplo:

DDRD= B00001111;

Dónde:

D es el puerto a controlar

B indica que es código binario

0 =entrada 1=salida

En este caso estamos declarando que la mitad de nuestro puerto sea entrada y la otra parte salida, con esto evitamos escribir varias veces “pinMode(x,OUTPUT)” para declarar cada pin.1

Tomando en cuenta que el primer número de la derecha es el menos significativo la relación de los pines será de la siguiente manera:

Si queremos hacerlo en forma decimal solo bastaría con escribir «31» y esto sería igual a activar los primeros cuatro pines como salida DDRD=31 ó DDRD=255 si queremos activar todo el puerto como salida.

PORT

Controlada si el pin esta en alto o bajo.

PORTD=10101010

Aquí asignamos que los pines 1, 3, 5, 7 estén en estado alto mientras que los pines 0, 2, 4, 6 están en estado bajo.

PIN

Lee el estado de los pines de entrada establecidos.

PIND

Se lee todo el puerto que se ha configurado como entrada. Este registro nos da un 1 si a un pin del microcontrolador se le está alimentando externamente, y un cero si esta en nivel bajo de voltaje.

Diagrama

En la siguiente imagen se muestra la conexión de un transistor con un segmento del display esto se tiene que hacer 7 veces, uno para cada segmento. Agregaremos un botón para hacer el conteo de forma manual.

Diagrama de conexión display 7 segmentos

Así quedara después de hacer las conexiones de los 7 segmentos.

Conexión del display 7 segmentos

Para hacer la secuencia de led’s es necesario hacer una tabla para saber que pines se encienden para cada uno de los 7 segmentos, se tomará como referencia un display convencional.

Imagen de referencia para la conexión

Display de 7 segmentos

Tabla de valores para los números

*NOTA: puedes ingresar todos los «1» y «0» o hacer la conversión a hexadecimal.

Programación

Este programa actúa como un contador, cada que se presione el botón sumara uno al conteo.

int x;
int contador=8;
int suma;

void setup()
{
// Serial.begin(9600);
pinMode(contador, INPUT);
DDRD=255; //se declara todo el puerto como salida
suma=0;
//HETPRO
PORTD=0x76; //H
delay(1000);
PORTD=0x79; //E
delay(1000);
PORTD=0x78; //t
delay(1000);
PORTD=0x73; //P
delay(1000);
PORTD=0x77; //R
delay(1000);
PORTD=0x3F; //O
delay(1000);
PORTD=0x00; //APAGA TODO
delay(1000);

}
void loop()
{
x=digitalRead(contador); //LEE SI ESTA ENESTADO ALTO EL BOTON
delay(150);
if(x==HIGH)
{
suma=suma+1; //AGREGA UNO AL CONTADOR
if(suma>9) // SI EL CONTADOR ES MAS DE NUEVE LO REINICIA A CERO
{
suma=0;
}
}
switch(suma){
//AL PUERTO "D" LE ASIGNAMOS EL NUMERO SEGUN SEA EL CASO
case 0:
PORTD=0x3F; //0
break;

case 1:
PORTD=0x06; //1
break;

case 2:
PORTD=0x5B; //2
break;

case 3:
PORTD=0x4F; //3
break;

case 4:
PORTD=0x66; //4
break;

case 5:
PORTD=0x6D; //5
break;

case 6:
PORTD=0x7D; //6
break;

case 7:
PORTD=0x27; //7
break;

case 8:
PORTD=0x7F; //8
break;

case 9:
PORTD=0x67; //9
break;
}
}

Prueba de display 7 Segmentos

Contador display 7 segmentos

Con esto queda terminado el display de 7 segmentos.

[youtube https://www.youtube.com/watch?v=kG8l0Ip5KRQ]

La entrada Modulo segmento display Grande aparece primero en Cuantex - Hardware Libre en México.

Pinguino PIC18 de Cuantex es una tarjeta de desarrollo con el microcontrolador de Microchip PIC18F4550 la cual se programa mediante el entorno de desarrollo Pinguino IDE. El Pinguino IDE es un entorno de desarrollo muy similar al de Arduino solo que èste es para procesadores de Microchip.

Puedes programar La Tarjeta Pinguino PIC18 en lenguaje C con las bibliotecas creadas por la comunidad Pingüino, el IDE es compatible con Sistemas Operativos de 32 o 64 bits GNU/Linux, Windows y MAC OS X, El pinguino IDE es Open Source y lo puedes descargar en el enlace que se encuentra en la secciòn de Paginas Recomendadas.

La diferencia que hay con Arduino UNO es que esta tarjeta tiene mas pines digitales y analògicos y también es compatible con todos los shield.

Sensor CNY70

El sensor CNY70 es un sensor infrarrojo de corto alcance basado en un emisor de luz y un receptor, ambos apuntando en la misma direcciòn. El funcionamiento es muy simple, el emisor siempre está emitiendo luz y una vez un objeto sea detectado dentro del rango de alcance refleja el rayo y es captado por el receptor. En la secciòn del emisor en el sensor se hace un arreglo PULL-UP con una resistencia de 10 Kilo ohms para que el microcontrolador pueda leer dos estados, nivel alto y nivel bajo (0 y 1).

Conexión del CNY70

Material utilizado

• Sensor CNY70
• Tarjeta Pinguino PIC18
• Protoboard
• Cables dupont Macho-Macho

Conexión con Tarjeta Pinguino

PIN 25 —————LED 1

PIN 26 —————LED 2

PIN 27 ————–CNY70

Código para Pinguino IDE

#define PIC18F4550
 
void setup()
{
pinMode(27,INPUT);
pinMode(25,OUTPUT);
pinMode(26,OUTPUT);
}

void loop()
{

if(digitalRead(27)==1)
{
digitalWrite(25,HIGH);
digitalWrite(26,LOW);
}
else
{
digitalWrite(25,LOW);
digitalWrite(26,HIGH);
}
}

Imágenes

Conexiòn del Pingüino con el CNY70

Detectando un Objeto

Objeto fuera del Rango de alcance

Enlaces de Interés

Pingüino IDE

Pagina del Fabricante

Hoja de datos de la tarjeta Pingüino PIC18

La entrada Pingüino PIC18 con CNY70 aparece primero en Cuantex - Hardware Libre en México.

RFID Shield PN532 NFC es una tarjeta lectora de módulos de RFID PN532 NFC con compatibilidad a Arduino. Solo la montas sobre algún Arduino y listo, tienes la conexión del hardware. Esta tarjeta es para los módulos RDIF/NFC de frecuencia 13.56Mhz. La tarjeta además tiene la capacidad de trabajar con los protocolos I2C y SPI. El PN532 es un módulo con alto nivel de integración con un procesador 80C51 interno para procesar los protocolos e información. El PN532 soporta 4 modos de operación que son: Lectura y escritura ISO 14443A, lectura y escritura ISO 14443B, Interfaz ISO 14443A y modo NFCIP-1. El PN532 soporta MIFARE y FeliCa. La tarjeta viene ya con todo lo necesario para comenzar a trabajar con módulos RFID NFC. La antena se diseñó para lecturas a aproximadamente de 1 a 4 centímetros sobre la superficie de la PCB. Esta tarjeta funciona con la biblioteca de Adafruit que puedes descargar en el siguiente link: Adafruit-PN532. Esta tarjeta funciona con 3.3V pero vienen ya configurada para trabajar a 5V para los pines Arduino por lo que no te tienes que preocupar por el voltaje de alimentación o de control.

Material:

• Tarjeta PN532 NFC
• Arduino 
• LED rojo
• LED verde
• Protoboard
• 2 Resistencias
• Tarjetas RFID 13.56Mhz
• jumpers macho-macho
• Celular con NFC

En este tutorial se va a utilizar la tarjeta RFID Shield PN532 NFC con el NFC de un celular y con tarjetas RFID de 13.56MHz al detectar el NFC enciende un LED ya sea que es rechazado o aceptado , no todos los  celulares cuentan con NFC la manera de activar el NFC de el celular es la siguiente:

• Entrar a configuración
• Otras redes
• Activar o desactivar NFC.

Descarga de biblioteca para Arduino

Esta tarjeta funciona con una biblioteca de Adafruit que se puede descargar en el siguiente link: https://github.com/adafruit/Adafruit-PN532

se descarga un archivo .ZIP, para agregar la biblioteca a arduino se da clic en programa, incluir librería, añadir librería  .ZIP y se selecciona la librería que se descargo.

Cargar programa a Arduino

#include <Wire.h>;
#include <Adafruit_NFCShield_I2C.h>;

#define IRQ   (2)
#define RESET (3) 
#define ledverde   3
#define ledrojo   4

Adafruit_NFCShield_I2C nfc(IRQ, RESET);

void setup(void) {
  Serial.begin(115200);
  Serial.println("Hello!");
  nfc.begin();
  pinMode( ledverde , OUTPUT );
  pinMode( ledrojo  , OUTPUT );

  uint32_t versiondata = nfc.getFirmwareVersion();
  if (! versiondata) {
    Serial.print("Didn't find PN53x board");
    while (1); 
  }
  
  Serial.print("Found chip PN5"); Serial.println((versiondata>>24) >> 0xFF, HEX); 
  Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
  Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
  nfc.setPassiveActivationRetries(0xFF);
  nfc.SAMConfig();
    
  Serial.println("Waiting for an ISO14443A card");
}

void loop(void) {
   digitalWrite (ledverde ,LOW);
   digitalWrite (ledrojo, LOW);
  boolean success;
  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  
  uint8_t uidLength;                        
  
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength);
  
  if (success) {
    String code = "";
    for (int i = 0; i < uidLength; i++)
    {
      
      code += String(uid[i], HEX);
    }
   
    code.toUpperCase();
    
    Serial.println(code);
    if (code == "DA9A142B" || code =="8ADF1477") //modificar a segun el valor de la tarjeta RFID que se colocara
    {
      Serial.println("Aceptado");
      digitalWrite (ledverde, HIGH);
       digitalWrite (ledrojo, LOW);
         delay(2000);
          digitalWrite (ledrojo, LOW);
          digitalWrite (ledverde ,LOW);
      
    }
    else
    {
      Serial.println("Rechazado");
      digitalWrite (ledrojo ,HIGH);
       digitalWrite (ledverde ,LOW);
            delay(2000);
            digitalWrite (ledrojo, LOW);
          digitalWrite (ledverde ,LOW);
    }
   
    delay(1000);
    
  }
  else
  {
    Serial.println("No se ha podido leer el TAG");
  }
}

Resultados

Se acercan las tarjeta RFID y el celular con el NFC encendido al módulo en la parte de la antena y el sensor la detecta:

Enlaces de interés:

Tarjeta PN532 NFC

Hoja de datos de la tarjeta

Hoja de datos del PN532

Tienda virtual HETPRO

Página de tutoriales CUANTEX

La entrada RFID Shield PN532 NFC aparece primero en Cuantex - Hardware Libre en México.

El modulo Bluetooth relevador tiene como controlador un ATtiny2313 de la familia Atmel y un modulo bluetooh HC-06, en este tutorial se explica la configuración para la comunicación serial para activar los relevadores. El software que se utiliza para hacer la programación es  AtmelStudio que es una plataforma para desarrollar aplicaciones para los microcontroladores AVR de Atmel en el cual  puedes programar en C/C++ o código ensamblador.

El código utilizado para el modulo Bluetooth relevador es muy corto ya que solo es para activar dos salidas del puerto B que corresponde a cada uno de los relevadores esto mediante la comunicación serial USART entre el bluetooth y el ATtiny2313. El programador que se utilizara para este tutorial sera el AVRDragon  que es el oficial de Atmel soporta AVR de 8 y 32 bits. se puede realizar depuraciones simbólicas en dispositivos con SPI, JTAGy PDI.

Materiales

• Modulo bluetooth relay
• Cables hembra-hembra
• Programador AVRDragon
• Fuente de alimentacion de 5v

Software ATmelStudio

Programación del Bluetooth relevador

Al iniciar  ATmelStudio se selecciona «New Proyect..»

Crear un nuevo proyecto

En seguida se abre una ventana con diferentes opciones de proyectos depende de que tipo de controlador y lenguaje requieres utilizar, para este tutorial se utilizara «GCC C++ Executable Proyect»  ya que crea un proyecto de un AVR de 8 bit en lenguaje C++.En seguida se nombra el archivo y se selecciona la ubicación del mismo y se pulsa «OK».

Tipos de Proyectos

 Al hacer esto debe de abrir una nueva ventana donde se busca y se selecciona el ATTiny2313 puesto que es microcontrolador que utiliza el modulo Bluetooth relevador. En esta apartado puedes encontrar la hoja de datos y herramientas que pueden soportar.

Seleccionar controlador del Bluetooth relevador

Con esto queda configurado el programa para poder iniciar a escribir el código.

Código Bluetooth relevador

/*
 * bluetooth_relay.cpp
 *
 * Created: 07/07/2016 15:38:40
 * Author: PC
 */
 
 
#include<avr/io.h>
#include<util/delay.h>
#include<avr/interrupt.h>
#define USART_BAUDRATE 9600
#define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)
char dato;
 
void InitUART(void) { //Configurando la UART
 
 UBRRL = BAUD_PRESCALE;
 UBRRH = (BAUD_PRESCALE >> 8);
 UCSRB = (1<<RXEN)|(1<<TXEN);;//habilita la transmision y recepcion de datos 
 UCSRC = (1<<USBS)|(3<<UCSZ0);//
 }
 
unsigned char ReceiveByte(void){ //Función para recibir un byte
 while (!(UCSRA & (1<<RXC)));//Esperar la recepción
 return UDR; //Retornar el dato tomado de la UART
}
 
int main (void) {
 
 DDRB=0xFF;
 InitUART(); //Inicializar la UART
 PORTB =0x00;
 while(1){
 
 dato=ReceiveByte(); //Recibir un dato de la UART
 
 if (dato==0x01) //Compara el dato recibido en hexadecimal
 {
 PORTB |= (1<<0);//al pin cero del puerto B le asigna un uno logico 
 }
 
 if (dato==0x02)
 {
 PORTB &=~ (1<<0);// al pin cero del puerto B le asigna la negacion de un uno logico 
 }
 if (dato==0x03)
 {
 PORTB |= (1<<1); //al pin uno del puerto B le asigna un uno logico 
 }
 
 if (dato==0x04)
 {
 PORTB &=~ (1<<1);// al pin uno del puerto B le asigna la negacion de un uno logico
 }
 
 }
}

Si no hay errores hacemos las conexiones entre el progrmador AVRDragon y el moduloBluetooth relevador,

Compilar código

Si no hay errores hacemos las conexiones entre el programador AVRDragon y el modulo Bluetooth relevador identificando los pines de comunicación SPI de cada uno.

*NOTA: Es necesario alimentar el modulo Bluetooth relevador con  una fuente de 5v antes de programar

En la barra herramientas seleccionamos «Tools»>>»Device Programming». Esto es para abrir el menú del programador.

En la ventana que se abrirá  se elige el programador, el microcontrolador y la interfaz serial, ya que estén seleccionados presionamos «Apply» y enseguida «Read» si todo esta bien conectado desplegara una serie de opciones para el controlador  de lo contrario se mostraran ventanas de ayuda.

Si reconoce el ATtiny2313 se da click en «Memories» y enseguida se selecciona la ubicacion del archivo HEX de nuestro programa que generalmente se encuentra en la misma carpeta que se definió al principio, para finalizar se da click en «Program» 

En caso de que no cuentes con el AVRDragon puedes utilizar cualquier otro programador compatible con el ATtiny2313 como el Programador HeTPro USBasp V3

La entrada Programacion Bluetooth con relevador aparece primero en Cuantex - Hardware Libre en México.

Características Generales MFRC522

• Distancia aproximada de detección del tag= 4 cms.
• Voltaje: 3.3 volts,
• 13 mA. Corriente máxima = 30 mA.
• Especificación del tag: Mifare MF1S503 con 1 Kb de EEPROM
• Frecuencia de operación: 13.56 Mhz
• Interfaz: conector header de 8 pines, SPI, con velocidad hasta 10 Mbps.
• Temperatura de operación: -20 a +60 grados C.
• Dimensiones: 40 x 60 mm.

Materiales

• Arduino UNO R3
• Modulo RFID-RC522
• Llaveto y/o tarjeta del modulo RFID-RC522 MFRC522
• Cables Jumper
• Protoboard
• 2 LEDs

Conexión del Modulo MFRC522 RFID-RC522 con Arduino

Librerías para el Arduino compatibles con MFRC522 

Descargar el Archivo ZIP: https://github.com/miguelbalboa/rfid

– Paso 1: Descargar todo el archivo ZIP

– Paso 2: Abrir el Programa Arduino, irse a la opción “Programa” situada en

– Paso 3: Seleccionas el Archivo ZIP que se descargo en el link de arriba

Código del Modulo RFID-RC522

#include <MFRC522.h>;
#include <SPI.h>;
/*
Pins SPI UNO
1 (NSS) SAD (SS) 10
2 SCK 13
3 MOSI 11
4 MISO 12
5 IRQ *No lo usaremos en este código 
6 GND GND
7 RST 5
8 +3.3V (VCC) 3V3
1 on ICPS header
*/
#define SAD 10
#define RST 9
MFRC522 nfc(SAD, RST);
#define ledAbierto 5
#define ledCerrado 6

void setup() {
pinMode(ledAbierto , OUTPUT);
pinMode(ledCerrado, OUTPUT);
SPI.begin();
Serial.begin(115200);
Serial.println("BUSCANDO MFRC522.");
nfc.begin();
byte version = nfc.getFirmwareVersion();

if (! version) {
Serial.print("NO SE ENCONTRO MFRC522 ");

while(1); //halt
}

Serial.print("BUSCANDO CHIP MFRC522 ");
Serial.print("FIRMWARE VERSION. 0x");
Serial.print(version, HEX);
Serial.println(".");
}

#define TARJETA 1
#define LLAVE 1
//CLAVE DE LA TAJETA
byte Autorizado[TARJETA][6] = {{0xF9, 0x84, 0x16, 0x2B, 0xFF, 0xFF, }};
// CLAVE DEL LLAVERO
byte Autorizado2[LLAVE][6] = {{0x32, 0x86, 0x7B, 0x6F, 0xFF, 0xFF, }};

void imprimeClave(byte *serial);
boolean esIgual(byte *key, byte *serial);
boolean chekaKey(byte *serial);

void loop() {
byte status;
byte data[MAX_LEN];
byte serial[5];
boolean Abierto = false;
digitalWrite(ledAbierto, Abierto);
digitalWrite(ledCerrado, !Abierto);
status = nfc.requestTag(MF1_REQIDL, data);
if (status == MI_OK) {
status = nfc.antiCollision(data);
memcpy(serial, data, 5);
if(chekaKey(serial)){
Serial.println("AUTORIZADO");
imprimeClave(serial);
Abierto = true;
}

else{
imprimeClave(serial);
Serial.println("NO AUTORIZADO");
Abierto = false;
}

nfc.haltTag();
digitalWrite(ledAbierto, Abierto);
digitalWrite(ledCerrado, !Abierto);
delay(2000);
}

delay(500);
}

boolean esIgual(byte *key, byte *serial){
for (int i = 0; i &lt; 4; i++){
if (key[i] != serial[i]){
return false;
}
}

return true;
}

boolean chekaKey(byte *serial){
for(int i = 0; i&lt;TARJETA; i++){
if(esIgual(serial, Autorizado[i]))
return true;
}

for(int i = 0; i&lt;LLAVE; i++){
if(esIgual(serial, Autorizado2[i]))
return true;
}

return false;
}

void imprimeClave(byte *serial){
Serial.print("CLAVE: ");
for (int i = 0; i &lt; 4; i++) {
Serial.print(serial[i], HEX);
Serial.print(" ");
}

}

La entrada RFID MFRC522 con Arduino UNO aparece primero en Cuantex - Hardware Libre en México.

GSM GPRS Shield SIMCom SIM900 Arduino MEGA 2560 es una tarjeta compacta de comunicación inalámbrica con el circuito SIM900 de SIMCom. La tarjeta es compatible con todos los modelos de Arduino con el formato UNO, además puedes controlarla con otros microcontroladores también. La tarjeta está basada en el módulo SIM900 que se maneja con el protocolo serial. En este tutorial vamos a ver como usar una biblioteca de la compañia Open Electronics que la puedes descargar de GitHub aqui: https://github.com/MarcoMartines/GSM-GPRS-GPS-Shield

GSM GPRS Shield SIMCom SIM900

La tarjeta GPRS Shield SIMCom SIM900 está configurada y controlada por vía UART usando comandos AT. En este caso la vamos a conectar de manera externa, ya que vamos a usar dos seriales por Hardware (a diferencia del otro tutorial). En este caso estamos usando el Serial 0 para visualizar datos en el COM del Arduino y el Serial 1 para comunicarnos con la tarjeta, por lo que vamos a hacer las siguientes conexiones:

• Vin – Vin (Se encuentra físicamente en la misma posición).
• GND – GND (Se encuentra físicamente en la misma posición).
• TX1 – El que corresponde al TX, o pin 1 en el formato UNO.
• RX1 – El que corresponde al RX, o pin 0 en el formato UNO.
• OJO: Poner los jumpers en la posición HW Serial, en este caso pegados conector J13.

Para ver la lista de comandos completa te recomendamos leer la hoja de datos de la tarjeta SIM900. Recuerda que esta tarjeta es Harwdare Libre por lo que puedes ver los esquemáticos y diseños de la misma como referencia para tu proyecto, o modificar los archivos para crear tu propia versión. SIM900 Arduino MEGA.

Especificaciones SIM900

• Compatible con Arduino.
• Conexión con el puerto serial UART.
• Quad-Band 850/ 900/ 1800/ 1900 Mhz.
• GPRS multi-slot clase 10/8.
• GPRS mobile station clase B.
• Compatible GSM fase 2/2+.
• Clase 4 (2 W (AT) 850 / 900 MHz).
• Clase 1 (1 W (AT) 1800 / 1900MHz).
• TCP/UP  embebido.
• Soporta RTC.
• Consumo de 1.5 mA (susp).

NOTA: Este shield GSM GPRS Solo ha sido probado con un SIM de la compañía celular UNEFON, IUSACELL y TELCEL.

Material

• Arduino Mega 2560 (SIM900 Arduino MEGA)
• GSM GPRS Shield SIMcom SIM900 Cuantex.
• Tarjeta SIM.

Procedimiento de uso SIM900 Arduino MEGA

1.- Insertar el SIM en el SIM HOLDER.

SIM montado en el sim holder.

2.- Montar el GSM GPRS Shield SIMCom SIM900 en el Arduino y energizarlo. Procurar conectar una fuente de poder, usualmente el puro USB no es suficiente para el SIM900 Arduino MEGA.

3.- Cargar el programa a utilizar. En este caso asumimos que ya se instalo (Copiar en el folder libraries) la biblioteca del SIM900 de Open Electronics.

4.- Presionar el botón de encendido por un segundo e inmediatamente encenderá el LED rojo que corresponde a net, después se encenderá el de status (LED verde) y se quedará parpadeando el LED rojo.

Indicadores del Shield GPRS Cuantex

5.- Presionar el botón de reset del Arduino.

Programa de prueba

El programa genera una evaluación del módulo SIM900 Mega 2560 en Arduino para su correcto funcionamiento, usualmente tarda entre 20 y 40 segundos en terminar la secuencia y procede a enviar el SMS. OJO En el siguiente código, lo único que tienes que cambiar es el numero de teléfono.

#include "SIM900.h"
#include <SoftwareSerial.h>
//If not used, is better to exclude the HTTP library,
//for RAM saving.
//If your sketch reboots itself proprably you have finished,
//your memory available.
//#include "inetGSM.h"

//If you want to use the Arduino functions to manage SMS, uncomment the lines below.
#include "sms.h"
SMSGSM sms;

//To change pins for Software Serial, use the two lines in GSM.cpp.

//GSM Shield for Arduino
//www.open-electronics.org
//this code is based on the example of Arduino Labs.

//Simple sketch to send and receive SMS.

int numdata;
boolean started=false;
char smsbuffer[160];
char n[20];

void setup()
{
     //Serial connection.
     Serial.begin(9600);
     Serial.println("GSM Shield testing.");
     //Start configuration of shield with baudrate.
     //For http uses is raccomanded to use 4800 or slower.
     if (gsm.begin(2400)) {
          Serial.println("\nstatus=READY");
          started=true;
     } else Serial.println("\nstatus=IDLE");

     if(started) {
          //Enable this two lines if you want to send an SMS.
          if (sms.SendSMS("3310xxxxxx", "Arduino SMS"))
          Serial.println("\nSMS sent OK");
     }

};

void loop()
{
     if(started) {
          //Read if there are messages on SIM card and print them.
        /**  deprecated method
        if(gsm.readSMS(smsbuffer, 160, n, 20)) {
               Serial.println(n);
               Serial.println(smsbuffer);
          }
          **/
          //get 1st sms
          sms.GetSMS(1,n,20,smsbuffer,160);
          Serial.println(n);
          Serial.println(smsbuffer);
         
          delay(1000);
     }
};

En la siguiente parte podemos ver el proceso que se sigue desde la Terminal de Arduino.

GSM Shield testing. 
ATT: OK 
RIC:  
ATT: OK 
RIC: AT 
 
OK 
 
DB:ELSE 
ATT: OK 
RIC: AT 
 
OK 
 
DB:ELSE 
ATT: OK 
RIC: AT 
 
OK 
 
DB:ELSE 
ATT: OK 
RIC: AT 
 
OK 
 
DB:CORRECT BR 
ATT: OK 
RIC: AT 
 
OK 
 
ATT: OK 
RIC: AT&F 
 
OK 
 
ATT: OK 
RIC: ATE0 
 
OK 
 
ATT: OK 
RIC:  
OK 
 
ATT: OK 
RIC:  
OK 
 
ATT: OK 
RIC:  
OK 
 
ATT: OK 
RIC:  
OK 
 
ATT: +CPMS: 
RIC:  
+CPMS: 20,20,20,20,20,20 
 
OK 
 
ATT: OK 
RIC: þ 
ATT: OK 
RIC:  
OK 
þ 
ATT: SHUT OK 
RIC:  
OK 
 
ATT: SHUT OK 
RIC:  
SHUT OK 
 

status=READY 
DEBUG:SMS TEST 
ATT: > 
RIC:  
OK 
 
>  
DEBUG:> 

Enlaces de Interés

• Hoja de datos de la tarjeta
• Hoja de datos del SIM900
• Hojas de aplicación SIM900
• Descarga el esqumatico y boardfile en EAGLE y PDF
• https://www.cuantex.com/tienda/

La entrada SMS SIM900 Arduino MEGA 2560 aparece primero en Cuantex - Hardware Libre en México.

GSM GPRS Shield SIMCom SIM900 es una tarjeta compacta de comunicación inalámbrica con el circuito SIM900 de SIMCom. La tarjeta es compatible con todos los modelos de Arduino con el formato UNO, además puedes controlarla con otros microcontroladores también. La tarjeta está basada en el módulo SIM900 que se maneja con el protocolo serial.

La tarjeta GPRS Shield SIMCom SIM900 está configurada y controlada por vía UART usando comandos AT. Solo conecta la tarjeta al Arduino, microcontrolador u otra tarjeta de desarrollo, y comienza a comunicarte. Ideal para sistemas remotos, comunicación recursiva, puntos de control, mandar mensajes de texto a celulares, etc. Para ver la lista de comandos completa te recomendamos leer la hoja de datos de la tarjeta SIM900. Esta tarjeta no se maneja con bibliotecas en particular debido a que los comandos son solamente caracteres que se envían por el puerto serial. Recuerda que esta tarjeta es Harwdare Libre por lo que puedes ver los esquemáticos y diseños de la misma como referencia para tu proyecto, o modificar los archivos para crear tu propia versión.

GSM GPRS Shield SIMCom SIM900

Especificaciones SIM900

• Compatible con Arduino.
• Conexión con el puerto serial UART.
• Quad-Band 850/ 900/ 1800/ 1900 Mhz.
• GPRS multi-slot clase 10/8.
• GPRS mobile station clase B.
• Compatible GSM fase 2/2+.
• Clase 4 (2 W (AT) 850 / 900 MHz).
• Clase 1 (1 W (AT) 1800 / 1900MHz).
• TCP/UP  embebido.
• Soporta RTC.
• Consumo de 1.5 mA (susp).

NOTA: Este shield GSM GPRS Solo ha sido probado con un SIM de la compañía celular UNEFON, IUSACELL y TELCEL.

Material

• Arduino UNO
• GSM GPRS Shield SIMcom SIM900 Cuantex.
• SIM

Conexiones

Para este módulo no es necesario utilizar cables ya que solo se monta sobre el arduino. El shield cuenta con un selector de UART que puede ser para los pines 0 y 1 o por SERIAL SOFTWARE que corresponden a los pines 7 y 8. Se recomienda utilizar los pines 7 y 8 por si necesitas hacer debug con la terminal serial del IDE Arduino.

Shield GSM GPRS montado en el Arduino UNO.

Procedimiento de uso

1.- Insertar el SIM en el SIM HOLDER.

SIM UNEFON montado en el sim holder.

2.- Montar el GSM GPRS Shield SIMCom SIM900 en el Arduino y energizarlo.

3.- Cargar el programa a utilizar.

4.- Presionar el botón de encendido por un segundo e inmediatamente encenderá el led rojo que corresponde a net, después se encenderá el de status (led verde) y se quedará blinkiando el led rojo.

Indicadores del Shield GPRS Cuantex

5.- Presionar el botón de reset del Arduino.

Programa de prueba

El programa consiste solo en que te marca por 30 segundos y despues te envia un mensaje de texto.

#include <SoftwareSerial.h>;
SoftwareSerial SIM900(7, 8); // Configura el puerto serial para el SIM900
 
char incoming_char=0; //Variable que guarda los caracteres que envía el SIM900
int salir = 0;
void setup()
{
SIM900.begin(19200); //Configura velocidad serial para el SIM900
delay(25000); //Retardo para que encuentra a una RED
Serial.begin(19200); //Configura velocidad serial para el Arduino
Serial.println("OK"); //Mensaje OK en el arduino, para saber que todo va bien.
}
 
void llamar()
// Función que permite llamar a un celular local
{

SIM900.println("ATD 333XXXXXXX;"); //tu numero Celular
delay(100);
SIM900.print("AT+CMGF=1\r"); // Comando AT para enviar mensaje
delay(100);
SIM900.println("AT + CMGS = \"33XXXXXXXX\""); // Tu numero celular
delay(100);
SIM900.println();
delay(30000); // espera por 30 seg
SIM900.println("ATH"); // Cuelga el teléfono
delay(1000);
}
void mensaje_sms()
//Funcion para mandar mensaje de texto
{
SIM900.print("AT+CMGF=1\r"); 
delay(100);
SIM900.println("AT+CMGS=\"33xxxxxxxx\""); // 
delay(100);
SIM900.println("Hola Mundo Cuantex"); // mensaje a enviar
delay(100);
SIM900.println((char)26); // End AT command with a ^Z, ASCII code 26 //Comando de finalizacion
delay(100);
SIM900.println();
delay(5000); // Tiempo para que se envie el mensaje
Serial.println("SMS sent successfully");
}
 
void espera_mensaje()
{
salir = 1;
while(salir==1)
{
if(SIM900.available() > 0)
{
incoming_char=SIM900.read(); //Get the character from the cellular serial port.
Serial.print(incoming_char); //Imprime en terminal lo que tiene la funcion Incoming char.
salir = 0;
}
}
}
void modo_recibe_mensaje()
{
//Configura el modo texto para enviar o recibir mensajes
SIM900.print("AT+CMGF=1\r"); 
delay(100);
SIM900.print("AT+CNMI=2,2,0,0,0\r");
 

delay(1000);
}
void loop()
{
llamar(); //Llama
mensaje_sms(); //Envia mensaje
modo_recibe_mensaje();
for(;;)
{
if(SIM900.available()>0)
{
 
incoming_char=SIM900.read(); //leer el caracter del puerto serial.
Serial.print(incoming_char); //Imprime lo que tiene la funcion Incoming Char en la terminal.
}
if(Serial.available() &amp;amp;amp;gt; 0)
{
if(Serial.read() == 'A') break;
}
}
Serial.println("OK-2");
 
delay(100);
SIM900.println();
delay(30000);
while(1); // Esperate por tiempo indefinido
 
}

En la siguiente imagen podemos ver el proceso que se sigue desde la Terminal de Arduino.

Enlaces de Interés

• Hoja de datos de la tarjeta
• Hoja de datos del SIM900
• Hojas de aplicación SIM900
• Descarga el esqumatico y boardfile en EAGLE y PDF
• https://www.cuantex.com/tienda/

La entrada GSM GPRS Shield SIMCom SIM900 aparece primero en Cuantex - Hardware Libre en México.