Archivo de la categoría: programación

Motor paso a paso 28BYJ-48 y AccelStepper

Objetivos

  • Montar un pequeño motor paso a paso 28BYJ-48 con su adaptador.
  • Escribir un primer programa de control utlizando la librería AccelStepper.

Material requerido

 arduino
  • Arduino Uno o similar. Esta sesión acepta cualquier otro modelo de Arduino.
 Img_3_4
  •  Una Protoboard.
 Img_3_6-300x185
  • Algunos cables de Protoboard.
FT68TVVHMMF4Z5P.LARGE_
  • Motor paso a paso 28BYJ-48 y adaptador

Motor paso a paso

Vamos a usar un pequeño motor paso a paso unipolar, muy común en el mundo Arduino por su pequeño tamaño y bajo coste, el 28BYJ-48 y el adaptador  que suele venir con él, basado en el chip ULN2003A.

FT68TVVHMMF4Z5P.LARGE_

El 28BYJ-48 tiene 64 pasos por vuelta y un reductor interno con una relación de 1/64. En conjunto hacen 4096 pasos por vuelta

Ya vimos como utilizar estos motores de forma manual en otra entrada, en ese caso se mandaban las señales una a una a cada bobina.

Ahora veremos como utilizar este motor paso a paso utilizando la librería AccelStepper.

Instalación de la biblioteca AccelStepper

Para controlar el motor paso a paso con lArduino, utilizaremos la librería AccelStepper. Esta librería permite mover fácilmente el motor un número definido de pasos, establecer su velocidad, aceleración y mucho más.

Puede consultar la documentación de la biblioteca AccelStepper aquí.

Pasos para instalar la librería AccelStepper en el IDE de Arduino:

Haz clic en el menú “Programa” -> Incluir librería -> Administrar bibliotecas… Busca “AccelStepper”. Instala la biblioteca AccelStepper de Mike McCauley. En este ejercicio se utilizó la versión 1.64.0.

image-1

Primer ejemplo de código

#include <AccelStepper.h>
#include <MultiStepper.h>

const int vuelta = 2048; // Cambia esto para ajustar el número de pasos por revolución.

// ULN2003 Motor Driver Pins
#define IN1 5 // puedes usar D1
#define IN2 4 // puedes usar D2
#define IN3 14 // puedes usar D5
#define IN4 12 // puedes usar D6

// initialize the stepper library
AccelStepper stepper(AccelStepper::HALF4WIRE, IN1, IN3, IN2, IN4);

void setup() {
    // initialize the serial port
    Serial.begin(115200);

    // set the speed and acceleration
    stepper.setMaxSpeed(500);
    stepper.setAcceleration(100);
    // set target position
    stepper.moveTo(vuelta);
}

void loop() {
    // check current stepper motor position to invert direction
    if(stepper.distanceToGo() == 0){
        stepper.moveTo(-stepper.currentPosition());
        Serial.println(«Changing direction»);
    }
    // move the stepper motor (one step at a time)
    stepper.run();
}

Explicación del código

En el código, primero se debe incluir la biblioteca AccelStepper.h.

#include <AccelStepper.h>

Se debe definir el número de pasos por revolución del motor paso a paso, en este caso es de 2048:

const int stepsPerRevolution = 2048; // cambiar esto para ajustar el número de pasos por revolución

Luego se deben definir los pines de entrada del motor. En este ejemplo, se conectan a los pines 5, 4, 14 y 12, pero se pueden usar cualquier pin.

Se debe inicializar una instancia de la biblioteca AccelStepper llamada stepper. Pasa como argumentos: AccelStepper::HALF4WIRE para indicar que se está controlando el motor paso a paso con cuatro cables y los pines de entrada. En el caso del motor paso a paso 28BYJ-48, el orden de los pines es IN1, IN3, IN2, IN4, puede ser diferente para otros motores.

AccelStepper stepper(AccelStepper::HALF4WIRE, IN1, IN3, IN2, IN4);

En el setup(), inicializa el Monitor Serial a una velocidad de baudios de 115200.

Usa el método setMaxSpeed() para establecer la velocidad máxima del motor paso a paso. Pasa como argumento la velocidad en pasos por segundo. La función run() acelerará hasta la velocidad establecida por esta función.

Se establece la aceleración usando el método setAcceleration(). Pasa como argumento la aceleración en pasos por segundo.

Luego, se usa el método moveTo() para establecer una posición objetivo. Luego, la función run() intentará mover el motor (como máximo un paso por llamada) desde la posición actual a la posición objetivo establecida por la llamada más reciente a esta función. Estamos estableciendo la posición objetivo en 2048 (que es una vuelta completa en el caso de este motor).

stepper.moveTo(vuelta);

En el loop(), haremos girar el motor paso a paso en sentido horario y antihorario.

Primero, verificamos si el motor ya ha alcanzado su posición objetivo. Para hacer eso, podemos usar la función distanceToGo() que devuelve los pasos desde la posición actual hasta la posición objetivo.

Cuando el motor alcanza su posición objetivo, significa que la función distanceToGo() devolverá 0 y la siguiente declaración if será verdadera.

if (stepper.distanceToGo() == 0){

Cuando el motor alcanza su posición objetivo, establecemos una nueva posición objetivo, que es la misma que la posición actual pero en dirección opuesta.

stepper.moveTo(-stepper.currentPosition());

Finalmente, llama a stepper.run() para mover el motor un paso a la vez en el loop().

stepper.run();

La función run() sondea el motor y lo mueve si es necesario, implementando aceleraciones y desaceleraciones para alcanzar la posición deseada. Debes llamar a esta función tan frecuentemente como sea posible, pero al menos una vez por el intervalo de tiempo mínimo de paso, preferiblemente en el loop().

Segundo ejemplo de código

#include <AccelStepper.h>

const int stepsPerRevolution = 2048;
// ULN2003 Motor Driver Pins
#define IN1 5 // puedes usar D1
#define IN2 4 // puedes usar D2
#define IN3 14 // puedes usar D5
#define IN4 12 // puedes usar D6
// Define el motor paso a paso y los pines que se utilizarán
AccelStepper stepper(AccelStepper::HALF4WIRE, IN1, IN3, IN2, IN4);

void setup() {
// Establece la velocidad máxima y la aceleración del motor
stepper.setMaxSpeed(1000);
stepper.setAcceleration(100);
}

void loop() {
// Mueve el motor 2048 pasos en una dirección
stepper.move(stepsPerRevolution );
stepper.runToPosition();

// Espera 1 segundo
delay(1000);

// Mueve el motor 2048 pasos en la dirección opuesta
stepper.move(-stepsPerRevolution );
stepper.runToPosition();

// Espera 1 segundo
delay(1000);
}

runToPosition()

Mueve el motor (con aceleración/desaceleración) a la posición objetivo y lo bloquea hasta que esté en la posición. No utilizar este método en bucles, ya que bloquea.

runToNewPosition()

runToNewPosition( long position)

Mueve el motor (con aceleración/desaceleración) a la nueva posición objetivo y lo bloquea hasta que esté en posición. No utilizar este método en bucles, ya que bloquea.
 

Sensor Óptico infrarrojo TCRT5000

El  Sensor Óptico TCRT5000 es un sensor ideal para detectar un cambio en la superficie sobre la cual está trabajando, El módulo incluye un sensor TCRT5000 óptico reflectivo infrarrojo, incluye el circuito Integrado LM393 como comparador de voltaje, es ideal para la detección de productos en bandas transportadoras y líneas de producción, líneas en robots de carreras seguidores de línea y sumos, aunque podemos encontrarle utilidad en cualquier otro proyecto electrónico que deseemos realizar.

Captura de pantalla 2023-11-01 a las 12.40.03

El TCRT5000 es un sensor que incluye el emisor y el receptor en el mismo empaquetado. El módulo funciona con IR lo que lo hace inmune a la luz visible.

Sigue leyendo

Módulo de pantalla de matriz de puntos LED I2C

El HT16K33 es un pequeño chip que tiene la capacidad de controlar una matriz multiplexada de 16×8 (es decir, 128 LED individuales). El protocolo de comunicación es I2C, por lo que utiliza solo 2 pines y puede tener hasta 8 direcciones I2C seleccionables, lo que da un total de 8 matrices, cada una de las cuales controla 16×8 LED para un total de 1024 LED.

matriz leds 16x8

A diferencia otros shield de LED, este módulo no tiene salidas para conectar otro módulo de LEDs.

Todo el control de LED se realiza a través de I2C utilizando la librería de interfaz HT16K33. Esto significa que SDA y SCL deben estar conectados con los pines A4 y A5.

La dirección predeterminada es 0x70 pero puede cambiar la dirección a 0x71-0x77 mediante un puente y soldando en los pines de dirección.

Software

Deberás instalar las siguientes librerías para utilizar este módulo.

Abra el administrador de librerías del IDE de Arduino:

Captura de pantalla 2023-11-01 a las 9.28.37

Sigue leyendo

Control de motores brushless

En esta entrada aprenderemos a controlar un motor sin escobillas (brushless) usando Arduino y ESC. En caso de que desee más detalles sobre cómo funcionan los motores BLDC, puede ver el siguiente video que contiene una explicación del principio de funcionamiento de un motor sin escobillas y cómo controlar uno usando Arduino y ESC.

Para este ejemplo, tengo un motor A2212 con las siguientes especificaciones: tiene una clasificación de KV de 2200, se puede alimentar con una batería LiPo 2S, 3S o 4S y requiere 30A ESC. La clasificación KV en un motor sin escobillas define las RPM del motor por voltio sin carga.

A2212

En este caso, los 2200KV significa que, por ejemplo, si alimentamos el motor con una batería LiPo 2S que tiene un voltaje de 7,4 voltios, el motor puede alcanzar RPM máximas de 7,4 veces 2200, o sea, 16280 RPM.

Los motores sin escobillas consumen mucha energía y el método más común para alimentarlos es usar baterías LiPo. El número «S» de una batería LiPo indica cuántas celdas tiene la batería, y cada celda tiene un voltaje de 3,7 V.

Para este ejemplo, usaremos una batería LiPo 3S que tiene 3 celdas y es de 11,1 V. Entonces, puedo esperar que mi motor alcance un máximo de RPM de 24420.

Por último, aquí hay un ESC 30A que usaré para este ejemplo y coincidiré con los requisitos del motor. Por un lado el ESC tiene tres cables que controlan las tres fases del motor y por otro lado tiene dos cables, VCC y GND, para alimentación.

esc

También hay otro conjunto de tres cables que salen del ESC y esa es la línea de señal, +5V y tierra. Esta función del ESC se llama circuito eliminador de batería y, como sugiere el nombre, elimina la necesidad de una batería separada para un microcontrolador. Con esto, el ESC proporciona 5V regulados que pueden usarse para alimentar nuestro Arduino. Esta conexión es en realidad la misma que vemos en los servomotores.

Entonces, controlar un motor sin escobillas usando ESC y Arduino es tan simple como controlar un servo usando Arduino. Los ESC usan el mismo tipo de señal de control que el servo y esa es la señal PWM estándar de 50 Hz.

Brushless-motor-control-signal-50hz-PWM-same-as-servo-motor-768x487

Esto es muy conveniente, ya que, por ejemplo, cuando construimos un avión RC, generalmente necesitamos tanto servos como motores sin escobillas y, de esta manera, podemos controlarlos fácilmente con el mismo tipo de controlador.

Entonces, usando el Arduino, solo tenemos que generar la señal PWM de 50 Hz y, según el ancho de los pulsos o la duración del estado alto, que debe variar de 1 milisegundo a 2 milisegundos, el ESC impulsará el motor desde RPM mínimas hasta máximas.

Diagrama de circuito

Aquí está el diagrama del circuito para este ejemplo. Además del ESC, solo usaremos un potenciómetro simple para controlar la velocidad del motor.

diagrama

Componentes necesarios:

  • Motor sin escobillas
  • ESC 30A
  • Batería Li-Po
  • Placa Arduino
  • Potenciómetro
  • Protoboard y Jump Wires

Código Arduino para control

El código Arduino es realmente simple con solo unas pocas líneas de código.

#include <Servo.h>
Servo ESC;     // Creamos el objeto servo (ESC)
int potValue;  // valor dle potenciometro

void setup() {
  // Asociamos el ESC al pin 9
// (pin, min pulse width, max pulse width in microseconds)
ESC.attach(9,1000,2000);
ESC.writeMicroseconds(900); // send “stop” signal to ESC.
delay(4000); } void loop() { potValue = analogRead(A0); // (valores entre 0 and 1023) potValue = map(potValue, 0, 1023, 0, 180); // mapeamos ESC.write(potValue); // enviamos señal }

Descripción:

  • Necesitamos importar la librería Servo, porque con esta librería podemos generar fácilmente la señal PWM de 50 Hz, de lo contrario, las señales PWM que genera el Arduino están en diferentes frecuencias.
  • Necesitamos crear un objeto servo para el control ESC y definir una variable para almacenar la entrada analógica del potenciómetro.
  • En la sección setup(), usando la función attach(), definimos en qué pin Arduino es la señal de control del ESC conectado y también definimos el ancho de pulso mínimo y máximo de la señal PWM en microsegundos.

En la sección de loop(), primero leemos el potenciómetro, asignamos su valor de 0 a 1023 a un valor de 0 a 180 (mapaemos). Luego, usando la función write(), para enviar la señal al ESC o generamos la señal PWM de 50 Hz. Los valores de 0 a 180 corresponden a los valores de 1000 a 2000 microsegundos definidos en la sección setup().

Si subimos este código a nuestro Arduino y luego lo encendemos todo usando la batería, podemos controlar la velocidad del motor de cero al máximo usando el potenciómetro.

IMPORTANTE: Sin embargo, hay algunas cosas que debemos tener en cuenta aquí. Al alimentar inicialmente el motor, el valor de la señal debe ser igual o inferior al valor mínimo de 1 milisegundo. Esto se denomina armado del ESC, y el motor emite un pitido de confirmación para que sepamos que está armado correctamente. En caso de que tengamos un valor más alto al encender, lo que significa que aceleramos, el ESC no arrancará el motor hasta que aceleremos hasta el valor mínimo correcto. Esto es muy conveniente en términos de seguridad, porque el motor no arranca en caso de que tengamos el acelerador activado al conectar la batería.

Calibración ESC

Por último, expliquemos cómo funciona la calibración ESC. Cada ESC tiene sus propios puntos altos y bajos, y pueden variar ligeramente. Por ejemplo, el punto más bajo podría ser 1,2 milisegundos y el punto más alto podría ser 1,9 milisegundos. En tal caso, nuestro acelerador no hará nada en el primer 20% hasta que alcance ese valor de punto bajo de 1,2 milisegundos.

ESC-Calibration-Pulse-Width-High-and-Low-Point-adjustment-768x695

Para solucionar este problema, podemos calibrar el ESC o configurar los puntos altos y bajos como queramos. Para ese propósito, antes de encender el ESC, primero debemos acelerar nuestro potenciómetro al máximo o un valor al menos mayor que el punto medio actual. Luego, podemos encender el ESC y escucharemos algunos pitidos del motor que en realidad confirman que hemos establecido el nuevo punto alto.

Luego, pasados 2 segundos, debemos mover nuestro potenciómetro a la posición donde indicamos cuál será el nuevo punto bajo. Volveremos a escuchar los pitidos de confirmación y con eso hemos terminado con la calibración ESC. Ahora nuestro acelerador responderá de inmediato y podremos controlar el motor dentro de estos dos nuevos puntos.

Arduino Joystick Shield Nrf24l01 Wireless

En este proyecto, estamos construyendo un robot de control remoto de dos ruedas utilizando módulos nRF24L01, un shield con joystick, un Ardunio UNO y un Arduino nano con un controlador de motor L298N para controlar los motores de CC.

arduino-joystick-schutzschild-arduino-5878-450x450

Los controladores de motor nRF24L01 y L298N juntos impulsarán el robot con el arduino nano como controlador. Además, para controlar este robot, estamos utilizando Arduino UNO con el módulo de joystick.

El shield proporciona una entrada analógica simple con el joystick y cuatro botones separados. También se incluyen dos pequeños botones adicionales.

El chip transceptor RF nRF24L01

El nRF24L01 es un chip transceptor de RF realmente rápido y económico. Funciona a 2,4 GHz a hasta 2 Mbps y tiene un consumo de energía ultra bajo, lo que significa que una batería AA/AAA se puede alimentar durante mucho tiempo. Funciona en un rango de suministro de 1,9 a 3,6 V con una corriente máxima de RX/TX de menos de 14 mA.

modulo-nrf24l01

Hardware requerido.

ArduinoUNO-300x300
  • Arduino UNO
nano
  • arduino nano
arduino-joystick-schutzschild-arduino-5878-450x450
  • Shield de joystick
l294n
  • Controlador de motor L298N
modulo-nrf24l01_bas
  • nRF24L01 x 2
chasis-de-vehiculo-robotico-para-arduino-pic-avr-etc-11690-MLM20046960131_022014-O
  • chasis y motores

Montaje del hardware emisor

Ensamblar el Arduino Uno y el shield juntos (con el nrf24).

arduino-robot-car-joystick

Esquema del robot

Siga el esquema de Fritzing y conecte todo al Arduino Nano como se muestra a continuación.

esquema

esq2esq1

Código emisor:

Pâra controlar al robot vams a mandar los mensajes «up», «down», «left», «right», «start», «select» y «analgobut». Con estos mensajes podremos tomar decisiones en nuestro robot, para ir hacia delante, atras, derecha, izquierda,…

//Arduino Joystick shield Code
#include <nRF24L01.h>
#include <RF24.h>
#include <SPI.h>


#define CE_PIN  9
#define CSN_PIN 10

int up_button     = 2; // Boton Amarillo - A
int down_button   = 4; // Boton Amarillo - C 
int left_button   = 5; // Boton Azul     - D 
int right_button  = 3; // Boton Azul     - B
int start_button  = 6; // Boton F
int select_button = 7; // Boton E
int analog_button = 8; // 
int x_axis = A0;
int y_axis = A1;
int buttons[]={up_button, down_button,left_button,
    right_button,start_button,select_button,analog_button};


const uint64_t pipe = 0xE8E8F0F0E1LL;
RF24 radio(CE_PIN,CSN_PIN);
char msg[20] = "";

void setup(){
     for(int i; i <7 ; i++){
         pinMode(buttons[i],INPUT);
         digitalWrite(buttons[i],HIGH);  
     } 
     Serial.begin(9600);
     radio.begin();
     radio.openWritingPipe(pipe);
}

void loop(){
      if(digitalRead(up_button)==LOW){
        char msg[]="up";
      radio.write(&msg,sizeof(msg));
      delay(300);
        Serial.println("UP Button Pressed");
      }
       if(digitalRead(down_button)==LOW){
        char msg[]="down";
        radio.write(&msg,sizeof(msg));
        delay(300);
        Serial.println("Down Button Pressed");
      }
       if(digitalRead(left_button)==LOW){
        char msg[]="left";
        radio.write(&msg,sizeof(msg));
        delay(300);
        Serial.println("Left Button Pressed");
      }
       if(digitalRead(right_button)==LOW){
        char msg[]="right";
        radio.write(&msg,sizeof(msg));
        delay(300);
        Serial.println("Rigth Button Pressed");
      }
       if(digitalRead(start_button)==LOW){
        char msg[]="start";
        radio.write(&msg,sizeof(msg));
        delay(300);
        Serial.println("Start Button Pressed");
      }
       if(digitalRead(select_button)==LOW){
        char msg[]="select";
        radio.write(&msg,sizeof(msg));
        delay(300);
        Serial.println("Select Button Pressed");
      }
       if(digitalRead(analog_button)==LOW){
        char msg[]="analgobut";
        radio.write(&msg,sizeof(msg));
        delay(300);
        Serial.println("Analog Button Pressed");
      }
      Serial.print("\n X = ");
      Serial.print(analogRead(x_axis));
      Serial.print(" \n Y = ");
      Serial.print(analogRead(y_axis));
      Serial.print("  ");
      delay(500);
}
Código robot receptor

// Arduino Car Code 
#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>


#define CE_PIN  9
#define CSN_PIN 10

const int RightMotorF= 3;
const int RightMotorB= 4;
const int LeftMotorF= 5;
const int LeftMotorB= 6;

char data[20]="";

RF24 radio(CE_PIN,CSN_PIN);
const uint64_t pipe = 0xE8E8F0F0E1LL;

void setup(){
  pinMode(RightMotorF,OUTPUT);
  pinMode(RightMotorB,OUTPUT);
  pinMode(LeftMotorF,OUTPUT);
  pinMode(LeftMotorB,OUTPUT);
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(1,pipe);
  radio.startListening();
}
 
void loop(){
  String msg="";
  if ( radio.available() ){
    radio.read( data,sizeof(data) );
    Serial.println(data);
    msg=data;
    if(msg=="up"){
  digitalWrite(RightMotorB,LOW);
  digitalWrite(LeftMotorB,LOW);
  digitalWrite(RightMotorF,HIGH);
  digitalWrite(LeftMotorF,HIGH);
  Serial.println("Motor forward");
  }
  else if(msg=="down"){
  digitalWrite(RightMotorB,HIGH);
  digitalWrite(LeftMotorB,HIGH);
  digitalWrite(RightMotorF,LOW);
  digitalWrite(LeftMotorF,LOW);
  Serial.println("Motor Back");
  }
   else if(msg=="left"){
  digitalWrite(RightMotorB,LOW);
  digitalWrite(LeftMotorB,HIGH);
  digitalWrite(RightMotorF,HIGH);
  digitalWrite(LeftMotorF,LOW);
  Serial.println("Left");
  delay(300);
  digitalWrite(RightMotorB,LOW);
  digitalWrite(LeftMotorB,LOW);
  digitalWrite(RightMotorF,LOW);
  digitalWrite(LeftMotorF,LOW);
  }
   else if(msg=="right"){
  digitalWrite(RightMotorB,HIGH);
  digitalWrite(LeftMotorB,LOW);
  digitalWrite(RightMotorF,LOW);
  digitalWrite(LeftMotorF,HIGH);
  Serial.println("right");
  delay(300);
  digitalWrite(RightMotorB,LOW);
  digitalWrite(LeftMotorB,LOW);
  digitalWrite(RightMotorF,LOW);
  digitalWrite(LeftMotorF,LOW);
  }
  else if(msg=="analgobut"){
  digitalWrite(RightMotorB,LOW);
  digitalWrite(LeftMotorB,LOW);
  digitalWrite(RightMotorF,LOW);
  digitalWrite(LeftMotorF,LOW);
  Serial.println("STOP it");
  }
  }
}

Probando el robot

Después de cargar el código tanto para el control remoto como para el robot, ¡es hora de probarlo! Aquí están los controles para el coche.

shieldexplica

Fuente:

https://maker.pro/arduino/projects/funduino-arduino-joystick-shield-controlled-robot

NodeMcu Esp3266 y display TFT ST7789

Objetivos

  • probar el display desde un nodemcu y visualizar diferentes mensajes e imágenes

Material requerido

esp8266.jpg
  • NodeMCU
shieldNodeMCU
  • shield NodeMCU
AR1717-TFT-Display-LCD-1.3-ST7735-v3-500x500
  • Pantalla TFT
Img_3_6-300x185
  • Cables

Repasemos funcionamientos

Para comenzar vamos a poner el enlace a la entrada donde se explican algunos conceptos para programar un NODEMCU.

Esquema.

El esquema del circuito del proyecto se muestra a continuación.

El módulo TFT ST7789 que se muestra en el esquema de circuito tiene 7 pines: (de derecha a izquierda):

  • GND (tierra),
  • VCC,
  • SCL (reloj en serie),
  • SDA (datos en serie),
  • RES (restablecimiento),
  • DC (o D/C : datos/comando)
  • BLK (luz de fondo).
  • La conexión del pin BLK es opcional. La luz de fondo se apaga cuando el pin BLK se conecta a tierra (GND).

esp8266-nodemcu-st7789-spi-tft-circuit

El módulo de pantalla TFT ST7789 está conectado a la placa NodeMCU de la siguiente manera:

  • GND está conectado al pin GND de la placa NodeMCU,
  • VCC y BL están conectados al pin 3V3,
  • El pin SCL está conectado a D5 (ESP8266EX GPIO14),
  • El pin SDA está conectado a D7 (ESP8266EX GPIO13),
  • El pin RES está conectado a D2 (ESP8266EX GPIO4),
  • El pin de CC está conectado a D1 (ESP8266EX GPIO5).

Si el módulo de visualización tiene un pin CS (selección de chip), debe conectarse al pin D8 de NodeMCU (GPIO15).

Los pines D5 (GPIO14) y D7 (GPIO13) son pines del módulo SPI de hardware del microcontrolador ESP8266EX respectivamente para SCK (reloj en serie) y MOSI (salida maestra-esclavo).

El programa de control

El siguiente código requiere dos bibliotecas de Adafruit Industries:

  • La primera biblioteca es un controlador para la pantalla TFT ST7789 que se puede instalar desde el administrador de bibliotecas IDE de Arduino (Sketch -> Incluir biblioteca -> Administrar bibliotecas…, en el cuadro de búsqueda escriba «st7789» e instale el de Adafruit).
  • La segunda biblioteca es la biblioteca de gráficos Adafruit que también se puede instalar desde el administrador de la biblioteca Arduino IDE.

Las 2 bibliotecas estarán incluidas en el código principal.

#include <Adafruit_GFX.h> // Biblioteca de gráficos central
#include <Adafruit_ST7789.h> // Biblioteca específica de hardware para ST7789

Las conexiones de los pines del módulo ST7789 TFT (CS, RST y DC) se definen como se muestra a continuación:
// Conexiones del módulo TFT ST7789
#define TFT_DC   D1 // El pin TFT DC está conectado al pin NodeMCU D1 (GPIO5)
#define TFT_RST D2 // El pin TFT RST está conectado al pin NodeMCU D2 (GPIO4)
#define TFT_CS    D8 // El pin TFT CS está conectado al pin NodeMCU D8 (GPIO15)

Los otros pines de pantalla (SDA y SCL) están conectados a los pines SPI del hardware NodeMCU (respectivamente D7 y D5).

La biblioteca Adafruit ST7789 se inicializa con esta línea:
// Inicializar la biblioteca Adafruit ST7789 TFT
Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_RST);

Y la pantalla TFT se inicializa con el siguiente comando:
// si la pantalla tiene un pin CS, intente con SPI_MODE0
tft.init(240, 240, SPI_MODE2); // Pantalla de inicio ST7789 240×240 píxeles

Es posible que la pantalla no funcione si tiene un pin CS, intente con SPI_MODE0, que es el modo predeterminado de la biblioteca, o simplemente use: tft.init (240, 240);

El resto del código se describe a través de comentarios.

 

Sigue leyendo

Dispensador de medicinas programable

Objetivos

  • construir un dispensador de pastillas.
  • que sea programable desde un móvil.

Material requerido

esp8266.jpg
  • NodeMCU
shieldNodeMCU
  • shield NodeMCU
FT68TVVHMMF4Z5P.LARGE_
  • Motor paso a paso 28BYJ-48 y adaptador
sg90
  • servo motor
Captura de pantalla 2022-01-24 a las 7.34.18
  • Display 16×2 con I2C
ds3231
  • Reloj RTC
pulsador
  • Un pulsador
buzzer
  • Un buzzer
D_NQ_NP_952506-MLM43973337619_112020-W
  • batería
cargador
  • Cargador de batería
Img_3_6-300x185
  • Cables

Repasemos funcionamientos

Para comenzar vamos a poner los enlaces a las entradas donde se explican los componentes por separado:

Esquema.

pilldispensor_bb

El programa de control

Paso 1: haremos un método o función para que cuando se le llame el motor paso a paso gire los grados deseados.

pill01

Sigue leyendo

ThingSpeak, NodeMCU y sensores LDR y DTH11.

Vamos a diseñar, cablear y programar una aplicación de manera que el microcontrolador NodeMCU ESP8266 lea la salida analógica del módulo del sensor de iluminación LDR.

También deberá leer la humedad relativa del aire y la temperatura en grados Celsius del módulo del sensor DTH11.

Toda esta información se mostrará de forma ordenada por el Monitor Serie del IDE de Arduino a intervalos de 20 segundos.

Cuando la lectura analógica del módulo LDR, esté por encima de 600 (luminosidad baja), mostraremos además el mensaje Iluminación: Desactivada y si está por debajo de 600 (luminosidad alta), mostraremos Iluminación: Activada. La salida del Monitor Serie podría tener el siguiente aspecto:

Captura de pantalla 2022-02-06 a las 20.22.36

Sigue leyendo

Pantalla Matricial 16×2 I2C

Captura de pantalla 2022-01-24 a las 7.34.18

En cualquier proyecto nos puede ser de mucha utilidad, poder mostrar información al exterior. Los LCD matriciales son los más simples y rápidos en el refresco de los caracteres mostrados, además de muy económicos. Sólo pueden mostrar caracteres alfanuméricos (ver ejemplo CustomChars de la librería LiquidCrystal_I2C.h) y los hay de 2 filas de 16 matrices (16×2) o de 4 filas de 20 matrices (20×4) generalmente. Poseen un potenciómetro incorporado para regular el contraste. Tienen retroiluminación para bfacilitar la lectura en ambientes oscuros que se puede desconectar por software o por Jumper externo).

Sigue leyendo