Plataforma Arduino

 Según la documentación oficial de Arduino:

"Arduino es una plataforma electrónica de código abierto basada en hardware y software fáciles de usar. Las placas Arduino pueden leer entradas (luz en un sensor, un dedo en un botón o un mensaje de Twitter) y convertirlo en una salida: activar un motor, encender un LED, publicar algo en línea. Puede decirle a su placa qué hacer enviando un conjunto de instrucciones al microcontrolador en la placa. Para ello se utiliza el lenguaje de programación Arduino (basado en Wiring ), y el Software Arduino (IDE) , basado en Processing."

Las ventajas que ofrece Arduino frente a otras plataformas es el costo al ser en comparación más baratas que otras, su IDE es multiplataforma (sistemas operativos Windows, Mac y Linux), el IDE es basado en Processing empleando el lenguaje C++ que permite agregar nuevas bibliotecas y expandír aún más la cantidad de componentes y sistemas con los que puede interactuar. Finalmente, tanto el hardware como el software es abierto y extensible.

Modelos de Arduino

Arduino UNO Características Voltaje de entrada: 6v - 20v Voltaje recomendado: 7v - 12v Voltaje de operación: 5v Pines digitales de entrada y salida: 14 (6 con salida PWM) Pines análogos de entrada y salida: 6 Dimensiones: 68.6 mm por 53.4 mm

Arduino NANO Características Voltaje de entrada: 7v - 12v Voltaje de operación: 5v Pines digitales de entrada y salida: 22 (6 con salida PWM) Pines análogos de entrada y salida: 8 Dimensiones: 18 mm por 45 mm

Arduino MEGA Características Voltaje de entrada: 6v - 20v Voltaje recomendado: 7v - 12v Voltaje de operación: 5v Pines digitales de entrada y salida: 54 (15 con salida PWM) Pines análogos de entrada y salida: 16 Dimensiones: 101.52 mm por 53.3 mm

Existen otros modelos como:

• Arduino Zero
• Arduino Due
• Arduino Leonardo
• Arduino Micro
• Arduino Yún

Cada uno con sus características propias y variantes. Además, de otros modelos orientados a IoT como el Arduino MKR

Fuentes:

• Arduino. (2018). ¿Qué es arduino?. Recuperado de: https://www.arduino.cc/en/Guide/Introduction
• Arduino. (2021a). Arduino Uno Rev3. Recuperado de: https://store-usa.arduino.cc/products/arduino-uno-rev3/
• Arduino. (2021b). Arduino Nano. Recuperado de: https://store-usa.arduino.cc/products/arduino-nano
• Arduino. (2021c). Arduino Mega 2560 Rev3. Recuperado de: https://store-usa.arduino.cc/products/arduino-mega-2560-rev3

Arduino básico

Proyectos básicos

En este caso se presentarán 5 aplicaciones básicas en Arduino empleando diodos led, resistencias, pulsadores, interruptores DIP y potenciómetros.

• EJERCICIO 01 - Encender y apagar un LED
• EJERCICIO 02 - Encender y apagar un LED con pulsador
• EJERCICIO 03 - Encender y apagar un LED con pulsadores sin mantener presionado
• EJERCICIO 04 - Encender y apagar varios LED con interruptores DIP
• EJERCICIO 05 - modificar la intensidad de un LED con un potenciómetro

EJERCICIO 01 - Encender y apagar un LED

El siguiente ejemplo encenderá un LED durante 3 segundos, luego lo apagará y así de forma consecutiva. Tener en cuenta que dependiendo del voltaje de funcionamiento del LED elegido se debe variar la resistencia para que este no resulte quemado y/o la luz se pueda apreciar.

Materiales:

• Arduino (Arduino UNO)
• Led (Verde con voltaje de 1.6v)
• Protoboard
• Cables dupont
• Resistencia de 680 ohmnios

Diagrama de conexión:

Código

//Constante que hace referencia al PIN donde se conecta el LED
const int LED = 8;

void setup(){
  pinMode(LED, OUTPUT);   //Indica que el Pin es de salida
  digitalWrite(LED, LOW); //Indica que el LED por defecto esta apagado
}

void loop(){
  digitalWrite(LED, HIGH); //Enciende el LED
  delay(3000);             //Espera 3000 milisegundos
  digitalWrite(LED, LOW);  //Apaga el LED
  delay(3000);             //Espera 3000 milisegundos
}

---

EJERCICIO 02 - Encender y apagar un LED con pulsador

El siguiente ejemplo encenderá un LED mientras un pulsador se mantenga presionado, si se suelta se apagará y así de forma consecutiva. Tener en cuenta que dependiendo del voltaje de funcionamiento del LED elegido se debe variar la resistencia para que este no resulte quemado y/o la luz se pueda apreciar. Además, la configuración de la resistencia del pulsador es "PULL-DOWN" y de 10 KΩ

Materiales:

• Arduino (Arduino UNO)
• Led (Rojo con voltaje de 1.2v)
• Protoboard
• Pulsador
• Cables dupont
• Resistencias de 560Ω (LED) y 10KΩ (pulsador)

Diagrama de conexión:

Código

//Constante que hace referencia al PIN donde se conecta el LED
const int LED = 12;
//Constante que hace referencia al PIN donde se conecta el pulsador
const int PUL = 7;

void setup(){
  pinMode(LED, OUTPUT);   //Indica que el Pin es de salida
  pinMode(PUL, INPUT);    //Indica que el Pin es de entrada
  digitalWrite(LED, LOW); //Indica que el LED por defecto esta apagado
}

void loop(){
  if(digitalRead(PUL)){           //Si el pulsador esta presionado
  	digitalWrite(LED, HIGH);      //Enciende el LED
  }else{                          //Si el pulsador deja de estar presionado
  	digitalWrite(LED, LOW);       //Apaga el LED
  }
}

---

EJERCICIO 03 - Encender y apagar un LED con pulsadores sin mantener presionado

El siguiente ejemplo encenderá un LED mientras al presionar un interruptor y se apagará al presionar otro, no es necesario mantenerlos presionados. Tener en cuenta que dependiendo del voltaje de funcionamiento del LED elegido se debe variar la resistencia para que este no resulte quemado y/o la luz se pueda apreciar. Además, la configuración de la resistencia de los pulsadores es "PULL-DOWN" y de 10 KΩ

Materiales:

• Arduino (Arduino UNO)
• Led (blanco con voltaje de 3.7v)
• Protoboard
• Pulsadores
• Cables dupont
• Resistencias de 100Ω (LED blanco) y 10KΩ (2 para los pulsadores)

Diagrama de conexión:

Código

const int LED = 8;
const int PUL_ON = 5;
const int PUL_OFF = 2;
boolean estado; //variable auxiliar para capturar el estado

void setup() {
  pinMode(PUL_ON, INPUT);
  pinMode(PUL_OFF, INPUT);
  pinMode(LED, OUTPUT);
}

void loop() {
  //Estado en TRUE si se presiona el boton del PIN 5
  if(digitalRead(PUL_ON)){estado = true;}
  //Estado en FALSE si se presiona el boton del PIN 2
  if(digitalRead(PUL_OFF)){estado = false;}
  //Dependiendo del estado se enciendo o apaga el LED
  if(estado){
  	digitalWrite(LED, HIGH);
  }else{
  	digitalWrite(LED, LOW);
  }
}

---

EJERCICIO 04 - Encender y apagar varios LED con interruptores DIP

El siguiente ejemplo encenderá varios LED mientras el interruptor correspondiente se mantenga en ON (cerrando circuito). Tener en cuenta que dependiendo del voltaje de funcionamiento del LED elegido se debe variar la resistencia para que este no resulte quemado y/o la luz se pueda apreciar. Además, la configuración de la resistencia de los interruptores es "PULL-DOWN" y de 10 KΩ

Materiales:

• Arduino (Arduino UNO)
• LES (Rojo con voltaje de 1.2v, blanco y azul con voltaje de 3.7v y amarillo con voltaje de 1.6v)
• Protoboard
• Conmutadores DIP de 4 canales
• Cables dupont
• Resistencias de 100Ω (LED blanco y azul), 220Ω (LED rojo), 390Ω (LED amarillo) y 10KΩ (4 para los conmutadores DIP)

Diagrama de conexión:

Código

//Constantes para los LED
const int LED1 = 7;
const int LED2 = 8;
const int LED3 = 12;
const int LED4 = 13;
//Constantes para cada conmutador
const int PUL1 = 5;
const int PUL2 = 4;
const int PUL3 = 3;
const int PUL4 = 2;

void setup(){
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);  
  pinMode(PUL1, INPUT);  
  pinMode(PUL2, INPUT);  
  pinMode(PUL3, INPUT);  
  pinMode(PUL4, INPUT);
}

void loop(){
  //Control del LED blanco con el conmutador 1
  if(digitalRead(PUL1)){
  	digitalWrite(LED1, HIGH);
  }else{
  	digitalWrite(LED1, LOW);
  }
  //Control del LED rojo con el conmutador 2
  if(digitalRead(PUL2)){
  	digitalWrite(LED2, HIGH);
  }else{
  	digitalWrite(LED2, LOW);
  }
  //Control del LED amarillo con el conmutador 3
  if(digitalRead(PUL3)){
  	digitalWrite(LED3, HIGH);
  }else{
  	digitalWrite(LED3, LOW);
  }
  //Control del LED azul con el conmutador 4
  if(digitalRead(PUL4)){
  	digitalWrite(LED4, HIGH);
  }else{
  	digitalWrite(LED4, LOW);
  }
}

Funcionamiento:

---

EJERCICIO 05 - modificar la intensidad de un LED con un potenciómetro

El siguiente ejemplo encenderá un LED y se controlará su intensidad empleando un potenciómetro. Tener en cuenta que dependiendo del voltaje de funcionamiento del LED elegido se debe variar la resistencia para que este no resulte quemado y/o la luz se pueda apreciar.

Materiales:

• Arduino (Arduino UNO)
• Led (blanco con voltaje de 3.7v)
• Protoboard
• Potenciómetro de 5KΩ
• Cables dupont
• Resistencias de 100Ω (LED blanco)

Diagrama de conexión:

Código

//El PIN del led debe ser PWM (tener el símbolo ~)
const int LED =11;
//El potenciómetro se debe conectar a un PIN analógico
const int POT = A0;
//Variable auxiliar para almacenar el valor del potenciómetro
int aux;

void setup(){
  pinMode(LED,OUTPUT);
  digitalWrite(LED,LOW);
}

void loop(){
  //Capturar el valor del potenciómetro
  aux = analogRead(POT);
  //Se emplea MAP para dar un valor análogo entre 0 y 255 al valor recibido entre 0 y 1023
  analogWrite(LED, map(aux,0,1023,0,255));  
}

• Documentación oficial sobre la función "map" de arduino: https://forum.arduino.cc/t/como-funciona-la-funcion-map/647033

Arduino y Processing - Encender y apagar un LED

 Diagrama de conexión

Código en Arduino

const int LED = 5;
char dato;

void setup() {
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
}

void loop() {
  if (Serial.available() > 0)
  {
    dato = Serial.read();
    if (dato == 'E') {
      digitalWrite(LED, HIGH);
    } else {
      digitalWrite(LED, LOW);
    }
  }
}

Código en Processing

import processing.serial.*;

Serial port;
String TITULO="Control de LED - Arduino";
PFont font;
int qx=150;
int qy=150;
int qr=50;
boolean state = false;
String texto;

void setup()
{  
  //println(Serial.list()); 
  port = new Serial(this, Serial.list()[0], 9600);
  size(300, 300);   
  font = createFont("Arial", 20, true);
  frameRate(10);
}

void draw()
{
  background(220, 220, 220); 
  textFont(font, 20);
  fill(0);
  textAlign(CENTER);
  text(TITULO, width/2, 60);

  fill(0);  
  stroke(0, 255, 0);

  if (mouseX > qx-qr  && mouseX < qx+qr && 
    mouseY > qy-qr && mouseY < qy+qr && mousePressed) {
    state=!state;
  }
  noStroke();
  if (state) {  
    fill(0, 0, 255);
    texto="ON";
    port.write('E');
  } else {  
    fill(255, 0, 0);
    texto="OFF";
    port.write('A');
  }  
  rectMode(RADIUS);
  rect(qx, qy, qr, qr);
  fill(0);
  text(texto, 150, 150);
}

Interfaz gráfica

Solución de Access denied en MySQL

Si aparece el error Access denied for user 'root'@'localhost' y se está empleando MySQL versión 8, la solución más sencilla es ejecutar en la línea de comandos de MySQL cualquiera de las siguientes sentencias dependiendo si se desea establecer o no una contraseña

Solución en LINUX

En el caso de LINUX el primer paso es abrir el terminal CTRL + ALT + T. Luego ingresar a la consola de MySQL con el comando:

sudo mysql -u root

Solución en WINDOWS

El primer paso en WINDOWS es abrir el CMD con WINDOWS + R o desde el menú inicio escribiendo CMD. Luego ingresar a la consola de MySQL con el comando:

mysql -uroot -p

---

Luego ingresar cualquiera de las siguientes dos opciones

Sin contraseña

  ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY ''
  

Con contraseña

  ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'clave';
  

Creando una tabla en SQLite

Crear la base de datos

Se requiere de un programa que administre bases de datos de SQLite para crear las bases de datos y opcionalmente comprobar si los cambios realizados por aplicaciones externas funcionan. Se puede emplear alguno de estos u otros: SQLiteStudio: https://sqlitestudio.pl/  DB Browser for SQLite: https://sqlitebrowser.org/ Las bases de datos de SQLite son archivos en lugar de un conjuntos de carpetas y archivos contenidos en un servidor, por lo cual no requieren un puerto.

Una vez instalado el programa, se selecciona la opción de agregar una base de datos

Se agrega una base de datos, se puede seleccionar una existente o crear una nueva

Se procede a crear una base de datos con la extensión "db" y luego realizar un test de conexión

Finalmente, aceptar

Crear la tabla

Mediante el programa se puede crear la tabla y las columnas seleccionando la base de datos:

Luego se debe seguir una serie de pasos para agregar columnas y configurarlas.

1. Indicar el nombre de la tabla
2. Agregar columnas
3. Indicar el nombre de la columna y su tipo, adicionalmente el tamaño. Por ejemplo, columnas que contienen texto o números con decimales.
4. Indicar los restricciones (constraints) como clave primaria, foránea, campo único, etc.
5. En algunos casos es necesario agregar una configuración adicional a las restricciones.
6. Por ejemplo, en los campos PRIMARY KEY de tipo entero, el autoincremento. Además, se puede colocar un nombre a la restricción. Por ejemplo, necesario para claves foráneas.
7. Finalmente aplicar cambios y repetir el proceso para cada columna que se desee agregar.

Se confirman los cambios, luego aparece el código SQL generado que se puede guardar para tener un Script.

Código SQL

Si se desea, se puede colocar el código directamente, para ello se debe seleccionar el editor SQL como se muestra.

En el editor SQL se debe ingresar lo siguiente y ejecutar (F9 en Windows).

CREATE TABLE inquilinos (
    idinquilinos  INTEGER         PRIMARY KEY AUTOINCREMENT,
    dni           VARCHAR (8)     UNIQUE
                                  NOT NULL,
    nombres       VARCHAR (150)   NOT NULL,
    paterno       VARCHAR (150)   NOT NULL,
    materno       VARCHAR (150)   NOT NULL,
    telefono      VARCHAR (40),
    correo        VARCHAR (200),
    deuda         DECIMAL (10, 2) NOT NULL,
    fecha_ingreso DATE            NOT NULL
);

Finalmente, se podrá apreciar la estructura de la tabla dentro de la base de datos. Cabe recordar que la base de datos "blog.db" es un archivo que estará ubicado en la dirección seleccionada inicialmente y puede ser trasladado donde deseemos.

Clases y objetos en C++

Objetos

Según la POO son bloques de código que permiten representar cosas (reales o imaginarias) como una persona o una venta. Los objetos se dividen en tres partes:

• El estado: conjunto de campos o variables (atributos o miembros)
• El comportamiento: las funciones (métodos o funciones miembro)
• La identidad: permite identificar un objeto de otro. De forma que cada objeto es identificable respecto a los demás.

Clases

Son estructuras que define las características que tendrá un objeto. Esto es lo que se llama encapsulamiento y es uno de los pilares de la POO.

Atributos

Son un conjunto de variables que definen el estado de una clase pueden ser tipos básicos:

• int
• float
• char
• bool
• Tipo colecciones (array), vectores u otros objetos.

Estas no deben ser accesibles desde el exterior, por lo que debe ser de tipo privado.

Metodos

Estos permiten acceder y modificar el estado de una clase.Tenemos dos clases especiales: el constructor y el destructor (el primero permite inicializar o instanciar una clase y el otro liberar recursos)

Además, existen los tradicionales métodos de acceso llamados GET que permiten extraer o mostrar el contenido de los atributos, generalmente sin parámetros salvo en colecciones u otros casos. Debe ser de tipo público. También, están los de modificación llamados SET que permiten modificar desde el exterior el contenido de los atributos asegurando la integridad de la clase, generalmente tienen un parámetro que coincide con el tipo de dato al que desean modificar y son públicos.

#include<iostream>
using namespace std;

class point{
	private:
		double x;
		double y;
	public:		
		//Constructor
		point(double x=0.0,double y=0.0):
			x(x),y(y)// Inicialización
			{}// Sin asignación
            
		//Métodos SET y GET	
		double getX() const {return this->x;}
		setX(double x){this->x=x;}
		double getY() const {return this->y;}
		setY(double y){this->y=y;}
		
		/*Destructor*/
		~point(){
			cout<<endl<<"Elemento destruido"<<endl<<endl;
		}		
};

Tangram con MiniWin

En el siguiente ejemplo se van a recrear las piezas de un tangram empleando triángulos rectángulos para formarlas.

Esto implica crear una o varias funciones para dibujar los triángulos rectángulos. En este caso se optó por usar cuatro funciones llamadas:

• tipoA
• tipoB
• tipoC
• tipoD

Estas podrían ser "inline", pero se optó por funciones convencionales, las funciones serían:

/*Trabajando con 4 tipos de triángulos rectángulos*/
void tipoA(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+ta-i,y1+i,x1+ta,y1+i);	
	}
}
void tipoB(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+i,y1+i);	
	}
}
void tipoC(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+i,y1+i,x1+ta,y1+i);	
	}
}
void tipoD(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+ta-i,y1+i);	
	}
}

Donde cada función corresponde a:

Tipo A	Tipo B
* ** *** **** *****	* ** *** **** *****
Tipo C	Tipo D
***** **** *** ** *	***** **** *** ** *

El código completo sería:

#include "miniwin.h"
using namespace miniwin;

const int DIM = 200; // Valor medio del ancho

/*Funciones */
void tipoA(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+ta-i,y1+i,x1+ta,y1+i);	
	}
}
void tipoB(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+i,y1+i);	
	}
}
void tipoC(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+i,y1+i,x1+ta,y1+i);	
	}
}
void tipoD(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+ta-i,y1+i);	
	}
}

int main(){
	vredimensiona(2*DIM, 2*DIM);	
	color_rgb(0, 0, 0);
	rectangulo_lleno(0, 0, 2*DIM, 2*DIM);
	
	/*Pieza 1*/
	color(AZUL);
	tipoB(0,0,DIM);
	tipoD(0,DIM,DIM);
	
	/*Pieza 2*/
	color_rgb(255, 150, 0);	
	tipoC(0,0,DIM);
	tipoD(DIM,0,DIM);	
	
	/*Pieza 3*/
	color(VERDE);	
	tipoA(DIM*1.5,0,DIM/2);
	rectangulo_lleno(DIM*1.5,DIM/2,2*DIM,DIM);
	tipoD(DIM*1.5,DIM,DIM/2);
	
	/*Pieza 4*/
	color(ROJO);	
	tipoA(DIM,DIM,DIM);
	
	/*Pieza 5*/
	color(MAGENTA);	
	tipoA(0,DIM*1.5,DIM/2);
	tipoB(DIM/2,DIM*1.5,DIM/2);
	
	/*Pieza 6*/
	color(AMARILLO);	
	tipoA(DIM/2,DIM,DIM/2);
	tipoB(DIM,DIM,DIM/2);
	tipoC(DIM/2,DIM*1.5,DIM/2);
	tipoD(DIM,DIM*1.5,DIM/2);
	
	/*Pieza 7*/
	color_rgb(100,0,155);	
	tipoA(DIM,DIM/2,DIM/2);
	tipoC(DIM,DIM,DIM/2);
	
	refresca();
	return 0;

}

El resultado visual sería: