Modulo no apilable

Un modulo no apilable es un circuito impreso (PCB) que no respeta el factor de forma de Arduino de modo que deberá ser conectado a través de cables.

A diferencian de los módulos apilables, los módulos no apilables no respetan el factor de forma de Arduino y normalmente se les conecta al Arduino a través de cables.

• SD
• RTC
• Ethernet
• WiFi
• Bluetooth
• USB
• GPS
• GSM
• RF 433 MHz
• RFID 125 KHz
• RFID MiFARE
• RFID UHF
• Reles
• Motores
• 8 digitos 7 segmentos

1. SD

Esta librería permite leer y escribir en tarjetas microSD, esto es una gran ventaja porque conservaras lo escrito así se quede sin energía el Arduino. La librería es compatible con los sistemas de archivos FAT16 y FAT32 en tarjetas SD estándar y tarjetas SDHC. Solo use nombres cortos de 8.3 para los archivos y carpetas. El pin out es directamente compatible con Arduino (5V) y también se puede usar con otros uC (3.3V). Nos permite agregar almacenamiento masivo y registro de datos a nuestro proyecto.

La comunicación entre el uC y la tarjeta SD usa SPI, que tiene lugar en los pines digitales 11, 12 y 13 (en la mayoría de las placas Arduino) o 50, 51 y 52 (Arduino Mega). Además, se debe usar otro pin para seleccionar la tarjeta SD. Este puede ser el pin SS de hardware - pin 10 (en la mayoría de las placas Arduino) o pin 53 (Arduino Mega) - u otro pin especificado en la llamada a SD.begin(). Tenga en cuenta que incluso si no usa el pin SS de hardware, debe dejarse como salida o la biblioteca SD no funcionará.

• SD.begin()
• SD.exist()
• SD.open()
• SD.read()
• SD.write()
• SD.remove()
• SD.mkdir()
• SD.rmdir()
• SD.close()

#include <SD.h>
File Archivo;

void setup() {
  //Se establece comunicación con el monitor serial para la comprobación de la carga de datos.
  Serial.begin(57600);
  Serial.print("Comenzando la comunicación con la tarjeta SD");

  //Se establece como salida el pin correspondiente a SS.
  pinMode(10, OUTPUT);

  //Estado SD
  if (!SD.begin(10)) {
    Serial.println("Se ha producido un fallo al iniciar la comunicación");
    return;
  }
  Serial.println("Se ha iniciado la comunicación correctamente");

  /*** INICIO ESCRITURA ***/
  Archivo = SD.open("datos.txt", FILE_WRITE);
  if (Archivo) {
     Archivo.println("Esto es lo que se está escribiendo en el archivo");
     Archivo.close();
     Serial.println("Todos los datos fueron almacenados");
  }else{
     Serial.println("El archivo datos.txt no se abrió correctamente");
  }
  /* FIN ESCRITURA */

  /*** INICIO LECTURA ***/
  Archivo = SD.open("datos.txt");
  if (Archivo) {
    Serial.println("Información contenida en datos.txt: ");
    While (Archivo.available()) {
      Serial.write(Archivo.read());
    }
    Archivo.close();
  }else{
    Serial.println("El archivo datos.txt no se abrió correctamente");
  }
  /* FIN LECTURA */
}

void loop(){
	//Si tengo algún dato para escribir
	if(tengo){
		/*** INICIO ESCRITURA ***/
		Archivo = SD.open("datos.txt", FILE_WRITE);
		if (Archivo) {
			Archivo.print("Valor pin 11: ");
			Archivo.println(digitalRead(11));
			Archivo.close();
			Serial.println("Dato almacenado");
		}else{
			Serial.println("El archivo datos.txt no se abrió correctamente");
		}
		/* FIN ESCRITURA */
	}
}

Modulo SD = 15 soles.

2. RTC

El Real Time Clock (RTC) es capaz de llevar la cuenta de la fecha y hora de manera automática, incluso continua funcionando sin energía gracias a una pila. Esta basado el DS1307 e incluye una memoria EPROM I2C. El asunto es que Arduino es incapaz de mantener la hora correctamente a largo plazo, debido a los microsegundos que se atrasan (o adelantan) al dividir la frecuencia del reloj principal para dar con el segundo exacto. Por esta razón tanto el Arduino como nuestra PC requieren de un circuito integrado especializado que incluye un oscilador a cristal de cuarzo de 32.768 KHz (2 elevado a la potencia 15). Dicho oscilador genera una frecuencia estable y divisible mediante hardware digital para lograr el segundo exacto. Este circuito integrado especializado normalmente también tiene la capacidad de funcionar en un modo de bajo consumo que permite alimentarlo con una batería pequeña.

El CHIP Maxim DS3231 es muy superior en precisión comparado el DS1307 que puede tener variaciones de 1 min por día por efectos de temperatura. EL DS3231 presenta desfases de 2 s/mes.

#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 rtc;

Los tipos de datos son: RTC_DS1307, RTC_Millis, Ds1307qwPinMode y DateTime

DateTime hoy = rtc.now();

#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 rtc;
//RTC_DS3231 rtc;
DateTime hoy;
 
void setup() {
   Serial.begin(57600);
   if (!rtc.begin()) {
      Serial.println("No encuentro tinyRTC");
      while (1);
   }
   if (!rtc.initialized()) {
      Serial.println("TinyRTC NO esta corriendo !");
      //Pone la fecha y hora de compilación
      RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
      //10 Marzo del 2018 at 19:42:00
      //RTC.adjust(DateTime(2018, 3, 10, 19, 42, 0));
   }
   pinMode(5, INPUT);
}
 
void loop() {
	if (digitalRead(5)){
		hoy = rtc.now();
		Serial.print('Fecha = ');
		Serial.print(hoy.year());
		Serial.write('-');
		Serial.print(hoy.month());
		Serial.write('-');
		Serial.print(hoy.day());
		Serial.print(' Hora = ');
		print2dig(hoy.hour());
		Serial.write(':');
		print2dig(hoy.minute());
		Serial.write(':');
		print2dig(hoy.second());
		Serial.write('.');
		Serial.print(millis());
		Serial.writeln();
		delay(1000);
	}
}
 
//Función para imprimir siempre 2 dígitos
void print2dig(int num) {
   if (num < 10) {
      Serial.write('0');
   }
   Serial.print(num);
}

La biblioteca RTClib.h agrega la funcionalidad de reloj a Arduino con o sin hardware RTC externo. Permite que un boceto obtenga la hora y la fecha como: segundo, minuto, hora, día, mes y año. También proporciona tiempo como C time_t estándar, por lo que los tiempos transcurridos se pueden calcular fácilmente y los valores de tiempo se pueden compartir en diferentes plataformas.

Modulo tiny RTC DS1307 = 10 soles

3. Ethernet

Estas librería están diseñadas para funcionar con Arduino Ethernet Shield (Ethernet.h) o Arduino Ethernet Shield 2 y Leonardo Ethernet (Ethernet2.h). Las librerías permiten que una placa Arduino se conecte a Internet. La placa puede servir como un servidor que acepta conexiones entrantes o un cliente que hace las conexiones salientes. Las librería admiten hasta cuatro conexiones simultáneas (entrantes o salientes o una combinación). La librería Ethernet (Ethernet.h) gestiona el chip W5100, mientras que la librería Ethernet2 (Ethernet2.h) gestiona el chip W5500.

Aunque aparentemente soporta 5V no funciona. Tienes que alimentarlo con 3.3V. Ademas el cable RJ-45 lo debes conectar a un router o switch no a tu PC.

Arduino se comunica con la nube usando el bus SPI. Esto está en los pines digitales 11, 12 y 13 (Arduino Uno) y los pines 50, 51 y 52 (Arduino Mega). En ambas placa, el pin 10 se usa como SS. Para saber mas.

#include <EtherCard.h>

static byte mymac[] = {0x74,0x75,0x76,0x00,0x30,0x31};
static byte myip[] = {192,168,1,203};
byte Ethernet::buffer[500];
BufferFiller bfill;
char* EstadoLed="OFF";

void setup () {
   Serial.begin(57600);
   Serial.println("Prueba del modulo Ethernet ENC28J60");
   if (ether.begin(sizeof Ethernet::buffer, mymac) == 0){
      Serial.println(F("No se ha podido acceder al controlador Ethernet"));
   }else{
      Serial.println("Controlador Ethernet inicializado");
   }
   ether.staticSetup(myip);
   pinMode(5, INPUT);
   pinMode(6, OUTPUT);
   digitalWrite(6, LOW);
   Serial.println("Listo..."); 
}

static word homePage() {
   long t = millis()/1000;
   word h = t/3600;
   byte m = (t/60)%60;
   byte s = t%60;
   bfill = ether.tcpOffset();
   bfill.emit_p(PSTR(
      "HTTP/1.0 200 OK\r\n"
      "Content-Type: text/html\r\n"
      "Pragma: no-cache\r\n"
      "\r\n"
      "<html><head><meta http-equiv='refresh' content='1'/>"
      "<title>Prueba Ethernet</title></head>" 
      "<body><h1>Hola mundo</h1>"
      "<h3>Tiempo: $D$D:$D$D:$D$D</h3>"
      "<p>Pulsador: $D</p>"
      "<p>Estado del LED: $S -- "
      "<a href='/?status=ON'><input type=button value=ON></a>"
      "<a href='/?status=OFF'><input type=button value=OFF></a>"
      "</body></html>"
  ),h/10, h%10, m/10, m%10, s/10, s%10, digitalRead(5),EstadoLed);
  return bfill.position();
}

void loop() {
   word len = ether.packetReceive();
   word pos = ether.packetLoop(len);

   //Verifica si recibiste data TCP valida
   if (pos){
      if (strstr((char *)Ethernet::buffer + pos, "GET /?status=ON") != 0) {
         digitalWrite(6, HIGH);
         EstadoLed = "ON";
      }
      if (strstr((char *)Ethernet::buffer + pos, "GET /?status=OFF") != 0) {
         digitalWrite(6, LOW);
         EstadoLed = "OFF";
      }
      Serial.println(EstadoLed);
      ether.httpServerReply(homePage()); //Envia data a pagina web
   }
}

El modulo con CHIP ENC28J60 usa esta libreria

• ether.begin()
• ether.staticSeptup()

4. WiFi

Con el modulo WiFi, esta biblioteca permite que una conexión a Internet. Puede servir como un servidor que acepta conexiones entrantes (servidor) o saliente (cliente). La librería admite el cifrado WEP y WPA2 Personal, pero no WPA2 Enterprise. También tenga en cuenta que si el SSID no se transmite, el modulo WiFi no podrá conectarse.

Arduino se comunica el modulo WiFi via el bus SPI. Esto está en los pines digitales 11, 12 y 13 (Arduino Uno) y los pines 50, 51 y 52 (Arduino Mega). En ambos placas el pin 10 se usa como SS. La librería WiFi es muy similar a la librería Ethernet y muchas de las llamadas a funciones son las mismas.

Es mucho mas recomendable usar un NodeMCU con ESP8266.

5. Bluetooth

Comunicación inalambrica de tu Arduino por bluetooth. Conecta con la UART o puerto serie. Pueden trabajar como maestro o esclavo, un esclavo solo puede conectarse a un maestro, sin embargo un maestro puede conectar a varios esclavos (max 7 esclavos), cada uno con una dirección única de 48 bits y un nombre. Tambien se puede establecer un protocolo IP sobre Bluetooth, con lo que podras ademas conectar via bluetooth a tu PC e internet.

Recuerda que antes de iniciar la comunicaciones los dispositivos bluetooth deben emparejarse.

Los modulos mas comunes son HC-05 (6 pines) y HC-06 (4 pines, solo esclavo).

Como el modulo Bluetooth es básicamente una comunicación serie, podríamos en principio conectar los pines RX y Tx a los equivalentes de Arduino, teniendo cuidado de crusarlos (Tx de BT a Rx de Arduino y Rx de BT a Tx de Arduino) y de hecho muchos ejemplos en Internet usan este esquema, permitiendote comunicarte con BT mediante las familiares instrucciones de Serial.print(). Sin embargo yo desaconsejo este método porque los pines Rx y Tx se usan en la comunicación serie de Arduino con el PC a través del USB, por lo tanto, si los usamos para comunicar con el modulo BT, perderíamos la conexión con el PC.

Por ello es mejor usar otro par de pines y la librería SoftwareSerial.h

#include <SoftwareSerial.h>
SoftwareSerial BT(2,3);  //RX,TX

#include <SoftwareSerial.h>
SoftwareSerial BT(2,3);  //RX,TX

void setup()   {
   Serial.begin(115200);
	//pinMode(4, OUTPUT);  //Pin Vcc del HC-05 (On/Off)
	//pinMode(5, OUTPUT);  //Pin KEY del HC-05 (HIGH = AT)
	//digitalWrite(5, HIGH);
	//delay(500);
	//digitalWrite(4, HIGH);
   BT.begin(9600);
   Serial.println("Mete comandos AT: ");
}

void loop()   {
   if (BT.available()){
      Serial.write(BT.read());
	}
   if (Serial.available()){  
		String cadena = "";
		char c = Serial.read(); ;
		while (c != '\n'){
			cadena += c ;
			delay(25) ;
			c = Serial.read();
		}
		cadena += c ;
      BT.print(cadena);
      Serial.println("---> " + cadena);
   }
}

#include <SoftwareSerial.h>
SoftwareSerial BT(2,3);  //RX,TX

void setup()   {
   Serial.begin(115200);
   BT.begin(57600);
}

void loop()   {
   if (BT.available()){
	   char c = BT.read();
      switch (c){
		case "A":
		   digitalWrite(10, HIGH);
         Serial.println("Prende 10");
			break;
		case "a":
		   digitalWrite(10, LOW);
         Serial.println("Apaga 10");
			break;
		case "B":
		   digitalWrite(11, HIGH);
         Serial.println("Prende 11");
			break;
		case "b":
		   digitalWrite(11, LOW);
         Serial.println("Apaga 11");
			break;
		}
	}
   if (Serial.available()){  
		String cadena = "";
		char c = Serial.read(); ;
		while (c != '\n'){
			cadena += c ;
			delay(25) ;
			c = Serial.read();
		}
		cadena += c ;
      BT.print(cadena);
      Serial.println("---> " + cadena);
   }
}

Para comunicar tu modulo Bluetooth con Android puedes usar las apps: Serial Bluetooth Terminal que es muy simple y no requiere cargar nada en Arduino o ArduDroid que es una app grafica que te permite prender/apagar todos los pines digitales (0~13), manejar salidas PWM, enviar y recibir comandos de texto. Documentacion aqui. Hay que cargar un boceto

Para conectar el modulo Bluetooth de Arduino con tu PC debes usar el software Putty. Si tu PC no tiene bluetooth ponle un modulo por USB y veras como se asocia un puerto COMx.

Para saber mas

Si bien es cierto que la librería SoftwareSerial.h permite la creación de múltiples puertos serie "virtuales", solo uno puede recibir datos a la vez. En todo caso se recomienda la librería AltSoftSerial.h

Modulo bluetooth HC-05 / HC-06 = 12 soles, modulos BLE no mucho mas caros.

6. USB

El modulo CP2102 es un conversor USB 2.0 de 12 Mbps a TTL, lo que permite que un computadora se comunique con un uC usando el protocolo USB. Es compatible con cualquier uC como PIC, Atmel AVR, Arduino y ESP8266. Funciona de forma similar a los conversores FTDI232 y PL2303HX, con la ventaja de tener un mejor precio y mayor soporte de drivers. Además puede funcionar como "programador" del Arduino Mini Pro, pues incluye el pin DTR o RESET necesario para cargar fácilmente el boceto al Arduino MINI Pro.

Para usar este modulo como programador debe conectar el módulo al Arduino MINI Pro usando los pines: +5V, GND, TXD, RXI y DTR. El pin DTR funciona como RESET, de esa forma cada vez que cargamos un boceto a nuestro Arduino, el programa "Resetea" al Arduino usando el pin DTR del módulo. También es usado para programar o "flashear" el chip ESP8266 en las versiones: ESP-01 y ESP-12E.

Modulo USB CP2102 = 12 soles

7. GPS

Como lo escuchas un modulo que proporciona a tu Arduino GPS, con un SD puedes guardar el log, conexión por puerto serie o directa.

#include <SoftwareSerial.h>
SoftwareSerial gps(4,3);
char dato=' ';

void setup(){
   Serial.begin(115200);            
   gps.begin(9600); 
}

void loop(){
   if (gps.available())  {
      dato = gps.read();
      Serial.print(dato);
   }
}

$GPRMC,044235.000,A,1207.2190,S,07659.6840,W,0.39,65.46,020618,,,A*44

• 044235.000 representa la hora GMT (04:42:35)
• "A" es la indicación de que el dato de posición está fijado y es correcto. "V" sería no válido
• 1207.2190 representa la longitud (12º 07.2190')
• S representa el Sur
• 07659.6840 representa la latitud (76º 59.6840')
• W representa el Oeste
• 0.39 representa la velocidad en nudos
• 65.46 representa la orientación en grados
• 020618 representa la fecha (2-JUN-2018)

#include <SoftwareSerial.h>
#include <TinyGPS.h>
TinyGPS gps;
SoftwareSerial ss(4, 3);

void setup(){
   Serial.begin(115200);
	ss.begin(9600);
	Serial.print("Simple TinyGPS library v");
	Serial.println(TyniGPS::library_version());
	Serial.println();
}

void loop(){
   bool newData = false;
	unsigned long chars;
	unsigned short sentences, failed;
	for (unsigned long start=millis(); millis()-start<1000;){
      while (ss.available()){
         char c = ss.read();
		   //Descomenta para ver data
         //Serial.write(c);
         if (gps.encode(c)){
            newData = true;
			}
      }
   }
   if (newData){
      float flat, flon;
      unsigned long age;
      gps.f_get_position(&flat, &flon, &age);
      Serial.print("LAT=");
      Serial.print(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0.0 : flat, 6);
      Serial.print(" LON=");
      Serial.print(flon == TinyGPS::GPS_INVALID_F_ANGLE ? 0.0 : flon, 6);
      Serial.print(" SAT=");
      Serial.print(gps.satellites() == TinyGPS::GPS_INVALID_SATELLITES ? 0 : gps.satellites());
      Serial.print(" PREC=");
      Serial.print(gps.hdop() == TinyGPS::GPS_INVALID_HDOP ? 0 : gps.hdop());
   }
   gps.stats(&chars, &sentences, &failed);
   Serial.print(" CHARS=");
   Serial.print(chars);
   Serial.print(" SENTENCES=");
   Serial.print(sentences);
   Serial.print(" CSUM ERR=");
   Serial.println(failed);
   if (chars == 0){
      Serial.println("** No characters received from GPS: check wiring **");
   }
}

Usa la libreria TinyGPS.h

8. GSM

Comunica vía GPRS usando una tarjeta SIM, usando SMS o mensajes de voz. También puede conectar a Internet.

Arduino no sera capas de alimentar este modulo, tendrás que poner una fuente externa. Para saber mas

9. RF 433 Mhz

El módulo RF 433MHz son transmisores/receptores inalámbricos que podemos emplear como una forma de comunicación entre procesadores como Arduino. Este tipo de módulos emisor (FS1000A) y el receptor (XY-MK-5V) se han hecho populares como medio de comunicación, principalmente, por su bajo costo. Usan bandas libres de 433MHz (también hay de 315MHz). El alcance depende de la tensión con que se alimente el módulo y el tipo de antena usado. A 5V y con la antena del módulo, el alcance difícilmente excederá de 2 m. Alimentando a 12V y con una antena de látigo de 165 mm o una helicoide de 45 mm de diametro x 34 mm de longitud, el rango en exteriores puede alcanzar 300 m.

La comunicacion es unidireccional, a una velocidad de 2400 bps. Se usa en recepcion remoto de sensores. Se usa la libreria VirtualWire.h

9.1 Emisor

#include <VirtualWire.h>
const int dataPin = 9;
 
void setup(){
   Serial.begin(9600);     
   vw_setup(2000);
   vw_set_tx_pin(dataPin);
}
 
void loop(){
   while (Serial.available()){
      char data[1];
      data[0] = Serial.read();
      vw_send((uint8_t*)data, sizeof(data));
      vw_wait_tx();
   }
   delay(200);
}

9.2 Receptor

#include <VirtualWire.h>
const int dataPin = 9;
const int ledPin = 13;
 
void setup(){
   vw_setup(2000);
   vw_set_rx_pin(dataPin);
   vw_rx_start();
    
   pinMode(ledPin, OUTPUT);
   digitalWrite(ledPin, LOW);
}
 
void loop(){
   uint8_t data;
   uint8_t dataLength = 1;
 
   if (vw_get_message(&data, &dataLength)){
      if ((char) data=='a'){
         digitalWrite(ledPin, HIGH);
      }else if ( (char) data=='b'){
         digitalWrite(ledPin, LOW);
      }            
   }
}

10. RFID 125 KHz

La distancia de lectura es de hasta 5 cm.

11. RFID MiFARE

El módulo lector RFID-RC522 RF usa 3.3V como alimentación y se controla a través del bus SPI. También puede ser controlada con un puerto UART. Entonces, podemos decir que es compatible con casi cualquier uC, Arduino o tarjeta de desarrollo. El RC522 usa un sistema avanzado de modulación y demodulación para todo tipo de dispositivos pasivos de 13.56 MHz (MiFARE). Incluso, puesto que 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 sobre hasta 16 Bytes. Finalmente el número de serie consiste de 5 dígitos hexadecimales, se podría usar esto para hacer una operación dependiendo del número de serie.

Usa la librería MFRC522.h

• MIFARE_Read()
• MIFARE_Write()

La distancia de lectura es de hasta 60 cm.

Near Field Communications o NFC es una forma de comunicarse entre dos dispositivos muy cercanos entre sí. Algo así como un bluetooth de muy corto alcance que no requiere autenticación. Es una extensión de RFID, por lo que cualquier cosa que pueda hacer con RFID lo puede hacer con NFC. También puede hacer más cosas con NFC, como comunicarse bidireccionalmente con teléfonos celulares. El PN532 es el chip NFC más popular y está integrado en casi todos los teléfonos o dispositivos que hacen NFC. Puede prácticamente hacer todo, como leer y escribir en etiquetas y tarjetas, comunicarse con teléfonos y 'actuar' como una etiqueta NFC. También puede funcionar con cualquier otra etiqueta NFC / RFID tipo 1 a 4.

El PN532 es muy flexible, puede usar 3.3V, TTL UART a cualquier velocidad en baudios, I2C o SPI para comunicarse con él. Este chip también puede usar el cable FTDI serie para comunicarse. Funciona a 13.56 MHz.

Modulo RC522 = 19 soles

12. RFID UHF

El un microchip que se anexa a una antena (el microchip y la antena en conjunto se denominan transpondedor de RFID o etiqueta de RFID). La antena permite que el microcircuito transmita la información de identificación a un lector. El lector convierte las ondas radiales emitidas por la etiqueta RFID en información digital que puede ser pasada a computadoras que la pueden usar.

La distancia de lectura es de hasta 6 m.

13. Reles

Pone a disposición de Arduino 4 reles para manejar dispositivos que no pueden controlarse directamente desde Arduino. Se usan solamente 4 pines digitales uno por rele. Existe una versión de 8 reles o mas pero usando el bus I2C para comunicarse.

Modulo 4 reles optoacoplados = 19 soles

14. Motores

Permite manejar fácilmente dos motores DC controlando su dirección y velocidad. Ocupa 4 pines de Arduino por canal.

Para saber mas

15. 8 dígitos 7 segmentos

Este es un modulo muy interesante porque solo contiene 2 elementos importantes: 2 displays de 4 dígitos cada uno y un integrado MX7219 que hace todo el trabajo con la librería LedControl. Los datos los envías en modo serie y hasta se pueden concatenar varios módulos. Aquí te explico mas del fabuloso MAX7219.

Evite usar los pines 0, 1 y 13.