fbpixel
Usando un módulo DS3231 con Arduino

Usando un módulo DS3231 con Arduino

Cada computadora está equipada con un reloj interno de tiempo real que le permite conocer la fecha. Los microcontroladores tipo Arduino no tienen RTC. El módulo DS3231 le da al Arduino la capacidad de calcular la fecha, permitiéndole controlar el tiempo con más precisión.

Hardware

  • Computadora
  • Arduino UNO
  • Cable USB A macho a B macho
  • Reloj en tiempo real DS3231

Principio de funcionamiento

Un módulo de reloj en tiempo real suele estar equipado con un oscilador de cuarzo para medir la hora y una batería para almacenar la hora incluso cuando la fuente de alimentación principal está apagada.

Esquema

El módulo DS3231 utiliza la comunicación I2C para interactuar con el microcontrolador. Así que lo conectamos:

  • SDA a la pin A4
  • SCL a la pin A5
  • VCC a la pin 5V
  • GND a la pin GND

Código

Para comunicar con el módulo DS3231, utilizamos la biblioteca DS3231.h que debe ser instalada en el administrador de la biblioteca. Cuando se usa por primera vez o se cambia la pila, la hora y la fecha no se ajustan. En el siguiente código, la fecha se puede establecer introduciendo la fecha deseada en el monitor de serie como YYMMDDwHHMMSSx. Una vez introducida la fecha, deberá reiniciar el tablero para que el módulo la tenga en cuenta.
Una vez que el reloj esté en la fecha correcta, puedes quitar la parte del código setDate y getDateStuff.

//Libraries
#include <Wire.h>//https://www.arduino.cc/en/reference/wire
#include <DS3231.h>//https://github.com/NorthernWidget/DS3231

//Variables
byte Year ;
byte Month ;
byte Date ;
byte DoW ;
byte Hour ;
byte Minute ;
byte Second ;
bool Century  = false;
bool h12 ;
bool PM ;

//Objects
DS3231 Clock;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  Wire.begin();
}

void loop() {
  setDate();
  readRTC();
}

void readRTC( ) { /* function readRTC */
  ////Read Real Time Clock
  Serial.print(Clock.getYear(), DEC);
  Serial.print("-");
  Serial.print(Clock.getMonth(Century), DEC);
  Serial.print("-");
  Serial.print(Clock.getDate(), DEC);
  Serial.print(" ");
  Serial.print(Clock.getHour(h12, PM), DEC); //24-hr
  Serial.print(":");
  Serial.print(Clock.getMinute(), DEC);
  Serial.print(":");
  Serial.println(Clock.getSecond(), DEC);
  delay(1000);
}

void setDate( ) { /* function setDate */
  ////Set Real Time Clock
  if (Serial.available()) {

    //int _start = millis();

    GetDateStuff(Year, Month, Date, DoW, Hour, Minute, Second);

    Clock.setClockMode(false);  // set to 24h

    Clock.setSecond(Second);
    Clock.setMinute(Minute);
    Clock.setHour(Hour);
    Clock.setDate(Date);
    Clock.setMonth(Month);
    Clock.setYear(Year);
    Clock.setDoW(DoW);

  }
}

void GetDateStuff(byte& Year, byte& Month, byte& Day, byte& DoW, byte& Hour, byte& Minute, byte& Second) { /* function GetDateStuff */
  ////Get date data
  // Call this if you notice something coming in on
  // the serial port. The stuff coming in should be in
  // the order YYMMDDwHHMMSS, with an 'x' at the end.
  boolean GotString = false;
  char InChar;
  byte Temp1, Temp2;
  char InString[20];

  byte j = 0;
  while (!GotString) {
    if (Serial.available()) {
      InChar = Serial.read();
      InString[j] = InChar;
      j += 1;
      if (InChar == 'x') {
        GotString = true;
      }
    }
  }
  Serial.println(InString);
  // Read Year first
  Temp1 = (byte)InString[0] - 48;
  Temp2 = (byte)InString[1] - 48;
  Year = Temp1 * 10 + Temp2;
  // now month
  Temp1 = (byte)InString[2] - 48;
  Temp2 = (byte)InString[3] - 48;
  Month = Temp1 * 10 + Temp2;
  // now date
  Temp1 = (byte)InString[4] - 48;
  Temp2 = (byte)InString[5] - 48;
  Day = Temp1 * 10 + Temp2;
  // now Day of Week
  DoW = (byte)InString[6] - 48;
  // now Hour
  Temp1 = (byte)InString[7] - 48;
  Temp2 = (byte)InString[8] - 48;
  Hour = Temp1 * 10 + Temp2;
  // now Minute
  Temp1 = (byte)InString[9] - 48;
  Temp2 = (byte)InString[10] - 48;
  Minute = Temp1 * 10 + Temp2;
  // now Second
  Temp1 = (byte)InString[11] - 48;
  Temp2 = (byte)InString[12] - 48;
  Second = Temp1 * 10 + Temp2;
}

Resultado

Una vez que se han inicializado la hora y la fecha y se ha reiniciado la tarjeta, la fecha se muestra cada segundo. Se ha añadido la función delay() para simplificar la visualización en el monitor de serie. En la práctica, no necesitará la función de retardo cuando utilice el módulo ds3231.

Aplicaciones

  • Hacer un despertador con Arduino

Fuentes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código

Usando un sensor PIR con Arduino

Usando un sensor PIR con Arduino

Es posible activar un sistema, como una alarma, detectando la presencia de una persona mediante un sensor de movimiento PIR. En la automatización del hogar, es una práctica común activar los dispositivos cuando una persona entra en una habitación. Esto es posible gracias a los sensores de movimiento como el sensor infrarrojo pasivo (PIR). Veremos en este tutorial cómo manejar el sensor PIR usando un microcontrolador Arduino.

Hardware

  • Computadora
  • Arduino UNO
  • Cable USB A macho a B macho
  • El sensor de movimiento PIR

Principio de funcionamiento

Cualquier objeto con una temperatura superior al cero absoluto emite radiación infrarroja. Esto es lo que podemos ver en las imágenes de la cámara térmica. El sensor PIR está equipado con dos células sensibles a los infrarrojos que detectarán los rayos infrarrojos reflejados o emitidos por un objeto.
Cuando no hay movimiento, el nivel de infrarrojos recibido es el mismo para ambas células. Durante el paso de un objeto, la emisión de estos rayos se modificará en una célula y luego en la otra, lo que permitirá detectar el movimiento.
La cubierta blanca, que suele cubrir y proteger el sensor, es una lente multifacética de Fresnel que enfoca y a veces filtra la radiación infrarroja en las células.

Esquema

El módulo PIR puede ser alimentado directamente por el microcontrolador y, al devolver un estado, la salida del sensor se conecta a una entrada digital.

Código

El sensor PIR devuelve un estado alto (HIGH) cuando detecta movimiento y un estado bajo (LOW) si no hay nada. Por lo tanto, se gestionará como una entrada digital utilizando la función digitalRead() de Arduino.

//Parameters
const int pirPin  = 2;

//Variables
bool pirStatus  = false;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init digital input
  pinMode(pirPin, INPUT);
}

void loop() {
  readPIR();
}

void readPIR( ) { /* function readPIR */
  ////Test routine for PIR
  pirStatus = digitalRead(pirPin);
  Serial.print(F("Sensor status")); Serial.println(pirStatus);
  if (pirStatus) {
    Serial.print(F("----> Detection"));
    delay(500);
  }
  delay(100);
}

Aplicaciones

  • Encender una luz cuando se detecta movimiento
  • Activación de una alarma ante la intrusión de una persona

Fuentes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código

Creando un sensor capacitivo con Arduino

Creando un sensor capacitivo con Arduino

Los sensores capacitivos se utilizan comúnmente para la detección de objetos. Pueden utilizarse, por ejemplo, para detectar el paso de un objeto en una cinta transportadora o para detectar el nivel de un líquido en un tanque. Más cerca de casa, los sensores capacitivos se usan en pantallas táctiles o como interruptores. En este tutorial veremos cómo crear un sensor capacitivo utilizando un simple conductor y un microcontrolador.

Hardware

  • Computadora
  • Arduino UNO
  • Cable USB A macho a B macho
  • Cable Dupont
  • Resistencia 1Mohm

Principio de funcionamiento

Un sensor capacitivo funciona como una antena que genera un campo eléctrico. Cuando un material se acerca a la antena, cambiará la capacidad de este campo. El microcontrolador detecta esta diferencia y puede determinar la proximidad del objeto. Con esta tecnología, es posible transformar cualquier objeto conductor en un sensor.

Esquema

Para crear un sensor táctil en un tablero de Arduino. Necesitará una resistencia y un cable y/o pintura conductora. La resistencia conecta la clavija de medición con la clavija de referencia y el cable va desde la clavija de medición a una hoja de papel de aluminio, pintura conductora o similar. El valor de la resistencia definirá la sensibilidad del sensor. Cuanto más alto sea el valor de la resistencia, más capaz será el sensor de detectar un objeto a distancia. Usamos una resistencia de 1MOhm pero puede elegir la más adecuada para su aplicación entre 500k y 40Mohm.

Hay microcontroladores como el NodeMCU (ESP8266 o ESP32) con sensores táctiles integrados. En este caso, un solo conductor conectado a la clavija es suficiente para crear un sensor capacitivo.

Código

Para usar el objeto Capacitivo usamos la biblioteca CapacitiveSensor.h. Para inicializar el sensor, tenemos que especificar los pines utilizados (aquí, 2 y 3). Es posible ajustar la sensibilidad del sensor durante la función de llamada cs.capacitiveSensor(sensitivity). Para tener más control sobre la precisión del sensor, usamos un promedio móvil gestionado por la función smooth() para filtrar las mediciones del sensor.

//Libraries
#include <CapacitiveSensor.h>//https://github.com/PaulStoffregen/CapacitiveSensor

//Parameters
bool autocal  = 0;
const int numReadings  = 10;
long readings [numReadings];
int readIndex  = 0;
long total  = 0;
const int sensitivity  = 1000;
const int thresh  = 200;
const int csStep  = 10000;
CapacitiveSensor cs  = CapacitiveSensor(2, 3);

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init cs
  if (autocal == 0) {
    {
      cs.set_CS_AutocaL_Millis(0xFFFFFFFF);
    }
  }
}

void loop() {
  Serial.println(smooth());
}

long smooth() { /* function smooth */
  ////Perform average on sensor readings
  long average;
  // subtract the last reading:
  total = total - readings[readIndex];
  // read the sensor:
  readings[readIndex] = cs.capacitiveSensor(sensitivity);
  // add value to total:
  total = total + readings[readIndex];
  // handle index
  readIndex = readIndex + 1;
  if (readIndex >= numReadings) {
    readIndex = 0;
  }
  // calculate the average:
  average = total / numReadings;

  return average;
}

Aplicaciones

  • Crear un interruptor táctil
  • Creando un sensor táctil o de proximidad

Fuentes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código

Usando un teclado digital 4×4 con Arduino

Usando un teclado digital 4×4 con Arduino

Ya sea una calculadora o el teclado de un edificio, usamos rutinariamente teclados numéricos. El teclado digital 4×4 es una matriz de 16 botones cuyos estados pueden ser detectados por un microcontrolador.

Hardware

  • Computadora
  • Arduino UNO
  • Cable USB A macho a B macho
  • Teclado digital 4×4

Principio de funcionamiento

El teclado numérico es un conjunto de 16 botones que están dispuestos en una matriz, es decir, todos los botones de una columna están vinculados a una entrada y todos los botones de una fila están vinculados a otra. Cuando se presiona un botón, la entrada correspondiente a la línea se conecta a la entrada correspondiente a la columna, lo que cierra el circuito. La ventaja de este tipo de montaje es que se pueden manejar 16 botones con sólo 8 entradas de microcontrolador.

Esquema

El teclado numérico utiliza 8 pines del Arduino. Es posible conectarlos a cualquier pin. Los pines 0 y 1, que se utilizan para la conexión en serie a través del puerto USB, deben evitarse.

Code

Para manejar el teclado numérico, el principio es pasar cada entrada de las columnas al estado alto y leer el valor de las entradas correspondientes a las filas. Si una fila tiene el mismo estatus que la columna, se presiona un botón. En la práctica podemos usar la biblioteca Keypad.h, que permite manejar una matriz de botones de cualquier tamaño.

//Libraries
#include <Keypad.h>//https://github.com/Chris--A/Keypad

//Constants
#define ROWS 4
#define COLS 4

//Parameters
const char kp4x4Keys[ROWS][COLS]  = {{'1', '2', '3', 'A'}, {'4', '5', '6', 'B'}, {'7', '8', '9', 'C'}, {'*', '0', '#', 'D'}};
byte rowKp4x4Pin [4] = {9, 8, 7, 6};
byte colKp4x4Pin [4] = {5, 4, 3, 2};

//Variables
Keypad kp4x4  = Keypad(makeKeymap(kp4x4Keys), rowKp4x4Pin, colKp4x4Pin, ROWS, COLS);

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
}

void loop() {
  readKp4x4();
}

void readKp4x4() { /* function readKp4x4 */
  //// Read button states from keypad
  char customKey = kp4x4.getKey();
  if (customKey) {
    Serial.println(customKey);
  }
}




Resultado

Cuando se pulsa una tecla del teclado, observamos que el carácter asociado se muestra correctamente en el monitor de serie.

Aplicaciones

  • Creando una interfaz con múltiples botones
  • Creando una cerradura operada por el teclado
  • Desarrolla una alarma que se activa o desactiva usando una contraseña

Fuentes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código

Usando un módulo MPU6050 con Arduino

Usando un módulo MPU6050 con Arduino

El módulo MPU6050 es una unidad inercial que mide la evolución de un objeto en el espacio. Puede medir las aceleraciones lineales y angulares en los tres ejes del espacio. Este componente se puede encontrar en varias aplicaciones como los controladores de videojuegos o los teléfonos inteligentes. Se puede usar para realizar el control de actitud de un dron o para equilibrar un robot sobre dos ruedas.

Para este tutorial, usaremos el módulo GY-521 en el que está integrado el MPU6050.

Prerrequisito: comunicación I2C

Hardware

  • Computadora
  • Arduino UNO
  • Cable USB A macho a B macho
  • MPU6050 (Module GY-521)

Principio de funcionamiento

El módulo GY-521 es un tablero de desarrollo para el sistema microelectromecánico MPU6050 (MEM- Sistemas microelectromecánicos). El módulo MPU6050 consta de un sensor de temperatura y dos sensores micromecánicos: un giroscopio para medir las rotaciones y un acelerómetro para medir las aceleraciones en el espacio. Estos sensores suelen constar de una parte mecánica y una parte piezoeléctrica. Cuando el objeto está en movimiento, la parte mecánica se mueve contra la parte piezoeléctrica que envía una señal eléctrica.

Esquema

El módulo puede ser alimentado directamente a través de la clavija de 5V en el tablero de Arduino. El módulo GY-521 utiliza la comunicación I2C para interactuar con el microcontrolador.

  • SDA al pin A4
  • SCL al pin A5
  • VCC al pin 5V
  • GND al pin GND

Código

Para interactuar con el módulo GY-521, y por lo tanto con el MPU6050, utilizaremos la biblioteca del mismo nombre Adafruit_MPU6050.h. Es importante tener en cuenta que, dependiendo del módulo utilizado, puede ser necesario modificar la dirección I2C para poder recuperar las mediciones. El código propuesto aquí es el programa básico para mostrar y utilizar las mediciones del sensor. La biblioteca ofrece muchos más ajustes y parámetros. Para más funcionalidades, no dude en consultar la documentación y los ejemplos de la biblioteca.

//Libraries
#include <Wire.h>//https://www.arduino.cc/en/reference/wire
#include <Adafruit_MPU6050.h>//https://github.com/adafruit/Adafruit_MPU6050
#include <Adafruit_Sensor.h>//https://github.com/adafruit/Adafruit_Sensor

//Objects
Adafruit_MPU6050 mpu;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init i2c (Default pins A4, A5)
  Wire.begin();
  if (!mpu.begin(0x69)) {
    Serial.println("Failed to find MPU6050 chip");
    while (1) {
      delay(10);
    }
  }

  mpu.setAccelerometerRange(MPU6050_RANGE_16_G);
  mpu.setGyroRange(MPU6050_RANGE_250_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
}

void loop() {
  readMPU();
  delay(100);
}

void readMPU( ) { /* function readMPU */
  ////Read acceleromter data
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);

  /* Print out the values */
  Serial.print("Acceleration X: ");
  Serial.print(a.acceleration.x);
  Serial.print(", Y: ");
  Serial.print(a.acceleration.y);
  Serial.print(", Z: ");
  Serial.print(a.acceleration.z);
  Serial.println(" m/s^2");

  Serial.print("Rotation X: ");
  Serial.print(g.gyro.x);
  Serial.print(", Y: ");
  Serial.print(g.gyro.y);
  Serial.print(", Z: ");
  Serial.print(g.gyro.z);
  Serial.println(" rad/s");

  Serial.print("Temperature: ");
  Serial.print(temp.temperature);
  Serial.println("°C");
}

Resultado

Una vez que el código ha sido cargado en el Arduino, si mueves el sensor, puedes ver que los valores de aceleración cambian en diferentes direcciones en el espacio. También puede comprobar el funcionamiento del sensor de temperatura pegando el dedo sobre el módulo.

Aplicaciones

  • Estabilizar un UAV
  • Controlar un robot con los movimientos de la mano
  • Darle equilibrio a un robot de dos ruedas

Fuentes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código