Como instalar un servidor FTP en una Raspberry Pi

En ocasiones necesitamos ubicar archivos en algún lugar y además queremos que estos archivos estén accesibles desde cualquier lugar que este en red,  para estos casos lo ideal es tener un servidor FTP.  Existen varias opciones para tener tu propio servidor FTP, en este tutorial vamos a ver como instalar un servidor FTP en una Raspberry Pi.

Existen varios software para instalar un servidor FTP en nuestra Raspberry Pi, uno de los más usados es el proFTPd, este Software es muy fácil de instalar y muy fácil de configurar, primero trataremos las instalación del mismo y a continuación veremos el archivo de configuración del servidor FTP en nuestra Raspberry PI.

Instalando proFTPd

La instalación de proFTPd, es muy simple y se realiza como cualquier otra instalación, para ello necesitamos abrir un terminal y descargar el paquete con el comando

Sudo get-apt install proftpd

Durante la instalación del servidor ftp proftpd, se nos preguntará que tipo de instalación queremos, “from inetd” o “standalone” , la diferencia entre ambas es que la instalación de proFTPd standalone configura el servidor para estar ejecutándose 24/7 mientras que la opción inetd solo ejecuta el servidor ftp cuando un cliente se conecta con lo que ahorra recursos de la Raspberry Pi.

Si vamos a disponer de varios usuarios que se pueden conectar simultáneamente y con cierta frecuencia, es recomendable utilizar la instalación de  proFTPd standalone.

FOTO1

Una vez instalado proFTPd, solo nos queda configurarlo  y crear y dar permisos a los usuarios que queramos.

Configurando proFTPd

Antes de comenzar con la configuración, vamos a hablar de los usuarios, básicamente, existen 3 tipos de usuarios:

  • Root
  • Usuario
  • Anonimus

proFTPd, puede actuar de diferente manera según el usuario que intente acceder al servidor, por ejemplo podemos denegar el acceso a los usuarios anónimos, permitir el acceso a una carpeta de usuario específica y permitir el acceso a todas las carpetas a los usuarios root. Por defecto proFTPd utiliza la lista de usuarios y passwords de la Raspberry Pi.

El usuario y password para root por defecto de Rasberry Pi son:

User: Pi

Password: Raspberry

Adicional mente si queremos crear un usuario simple sin derechos de administrador, lo creamos con el comando:

sudo adduser usuario1

y le añadimos un password con el comando:

sudo passwd  usuario1

Creamos la carpeta destino donde podrán acceder los usuarios normales

Sudo mkdir FTPfolder

Ahora que ya tenemos creados los usuarios, vamos ver como configuramos proFTPd y permitir o denegar el acceso a los diferentes usuarios.

La configuración del servidor FTP, se realiza a través del archivo de configuración  proftpd.conf, para editarlo, ejecutamos el comando:

sudo nano /etc/proftpd/proftpd.conf

Este archivo configura el propio servidor y por otro lado la gestión de los usuarios,  es recomendable dejar la configuración por defecto del servidor,  aunque podemos cambiar el nombre del servidor, el tipo de servidor, el timeout etc…

Para asignar la carpeta que hemos creado al usuario que hemos creado, añadimos la línea:

DefaultRoot /home/FTPfolderusuario1 

Con la línea anterior asignamos al usuario1 la carpeta destino FTPfolder, pero permitimos al usuario root el acceso a todas las carpetas.

Para no permitir las conexiones de usuarios Anonymus, nos aseguramos que no hay código entre las etiquetas <Anonymous ftp> y </Anonymous> o directamente borramos el bloque entero.

Si quieres saber más sobre la gestión de los usuarios te recomiendo que visites la página de los creadores proFTPd

Una vez realizados los cambios oprtunos guardamos el archivo y volvemos a cargarlo para que se apliquen los cambios

sudo service proftpd reload

Ya tenemos nuestro servidor FTP funcionando…

Accediendo al servidor FTP.

Para verificar que todo está en orden y funciona correctamente, abrimos un navegador de internet y escribimos la dirección de nuestro servidor FTP

ftp://<IP-Rapsberry> 

Si todo ha funcionado, el navegador nos debería mostrar nuestra carpeta destino, según el usuario con el que estemos logeados en la Raspberry

Para poder subir ficheros desde cualquier ordenador se puede utilizar cualquier cliente FTP disponible como FILEZILLA, WinSCP, etc…

Como conectarnos a un módulo ESP32-CAM desde Python

Hoy en día la difusión multimedia está muy extendida e integrada en nuestras vidas sin que seamos consciente de ello, el termino stream lo relacionamos con la reproducción de información de audio o video. Esta información puede estar disponible en forma de archivo como puede ser un archivo de video o audio almacenado en el disco de un servidor o bien puede ser una cámara IP a la cual podemos acceder para ver la imagen en tiempo real.

Una de las grandes ventajas del streaming es que la información se muestra en tiempo real, es decir, no es necesario descargar el archivo completo para poder verlo o escucharlo.

Existen varios protocolos para poder hacer streaming, algunos son más avanzados como puede ser RSTP, que da la posibilidad de pausar, la reproducción y otros más simples que no ofrecen ningún control.

En este tutorial, vamos ver como conectarnos a un módulo ESP32-CAM desde Python con la librería OPENCV, mediante Http.

Es necesario que en el IDE que utilices tengas instaladas las tarjetas ESP32, si no las tienes, en el IDE de arduino ves a archivo–> preferencias  y en el gestor de URLs adicionales de tarjetas pega la siguiente dirección:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json 

Ahora vamos a Herramientas–> Placa –> Gestor de tarjetas y buscamos ESP32 (expressif) e instalamos la última versión disponible.

Seleccionamos la placa AI Thinker ESP32-CAM (aunque sea el clon de china) y el puerto serie correspondiente, seleccionando esta placa, no es necesario realizar nada más, las particiones ya se configuran solas.

Lo primero que hacemos será cargar en el módulo ESP32-CAM el software de ejemplo para la cámara,  recordar que tenemos que introducir el SSID de nuestra red y el Password.

Este módulo viene sin una interface para poder subir el SW, por lo que para poder subir el SW al módulo necesitaremos un conversor USB a TTL y conectarlo al ESP32-CAM tan y como se ve en la imagen.

Solo nos queda compilar y subir el SW al ESP32-CAM, una vez se ha subido el software, eliminamos el puente entre  D01 y GND y apretamos el botón de Reset. Si lo hemos hecho bien, en modulo se conectará a nuestra red Wifi y por la consola nos indicará la IP asignada y los puertos asignados para Web Server y para el Streaming de video, será el puerto 81.

Necesitamos apuntar la IP y toda la ruta para que desde Python podamos acceder a la cámara, esta ruta debería ser algo:

http://<tu_ip_asignada>:81/stream 

Para verificar que es la url correcta, cópiala  en el navegador y deberías tener acceso directo al video, si no es así, hay algo que no tienes bien.

Es hora de ponernos con Python, para ello hemos de tener instaladas las librerías OpenCV y numpy.

Accederemos a la cámara mediante su dirección IP, para ello abrimos la url y buscamos el inicio y final de la imagen enviada, una vez sabemos la ubicación y la longitud de la imagen, la decodificamos y la mostramos en una ventana.

import cv2
from urllib.request import urlopen
import numpy as np

stream = urlopen('http://192.168.43.6:81/stream')
bytes = bytes()
while True:
    bytes += stream.read(1024)
    a = bytes.find(b'\xff\xd8')
    b = bytes.find(b'\xff\xd9')
    if a != -1 and b != -1:
        jpg = bytes[a:b+2]
        bytes = bytes[b+2:]
        if jpg :
            img = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8), cv2.IMREAD_COLOR)
            cv2.imshow('ESP32 CAM', img)
    if cv2.waitKey(1) & 0xff == ord('q'):
        break
stream.release()
cv2.destroyAllWindows()

En la variable img tenemos la imagen que nos envía el ESP32-CAM, podemos guardar, reenviarla, tratarla, buscar algún objeto, etc…  a partir de aquí es cosa tuya….

Puedes descargar el script para Python 3 desde mi repositorio.

Sensor de temperatura con Arduino y Termistor

Hoy en día es posible hacer un medidor de temperatura de varias maneras, aquí os explicaré como hacer un sensor de temperatura con Arduino y un termistor.  Un termistor es un componente pasivo bastante barato comparado con sensores digitales para medición de temperatura. Para poder interactuar con los sensores digitales, arduino necesita las librerías específicas, las cuales las podemos encontrar por la red o las podemos programar con ayuda de los datasheet…

Básicamente un termistor es una resistencia que varía su valor en función de la temperatura del entorno. Existen 2 tipos de termistores que se categorizan en PTC (Positive Temperature Coefficient) y NTC (Negative Temperature Coefficient), la diferencia es que las PTC aumentan su resistencia con el aumento de temperatura y las NTC disminuyen su resistencia  con el aumento de temperatura.

En este tutorial, vamos a utilizar el típico termistor  que utilizan lasimpresoras 3D en el extrusor, son muy baratos y muy fáciles de encontrar. El modelo que utilizaré es de 100K y un coeficiente B 3950, estos dos valores son básicos para poder hacer los cálculos y conversiones a temperatura.

Termistor NTC 100K 3950 Arduino

Los 100K es el valor de la NTC que nos indica el fabricante para una temperatura ambiente de 25ºC, y el parámetro B y una constante que define la curva de temperatura del termistor, este parámetro nos lo da el fabricante.

Circuito básico del termistor

Como he dicho anteriormente, un termistor es un elemento pasivo resistivo,  que varía su resistencia en función de la temperatura, por lo que si sabemos el valor de la resistencia del termistor, podremos calcular la temperatura.

Para conocer el valor del termistor, 

colocamos una resistencia en serie con el termistor y medimos la caída de tensión en el termistor, una vez conocemos la caída de tensión en el termistor, conoceremos la caída de tensión en la resistencia y con un  simple divisor de tensión conoceremos el valor resistivo de la NTC.

Divisor de tension Arduino

En el circuito de la figura anterior la salida VOUT viene dada por la fórmula:

Vout=\frac{R2}{R1+R2}*Vcc

Si consideramos que VOut, la mediremos con el ADC (VADC) de arduino, R1 = 100K y VCC = 3v3 y su valor en el ADC 1023, podemos despejar R2 para conocer el valor del termistor:

R2=\frac{Vout*R1}{Vcc-Vout}= \frac{Vadc*100k}{1023-Vadc}

R2=\frac{Vadc*R1}{1023-Vadc}

Conversión a temperatura

Y ahora que ya conocemos el valor resistivo del termistor que hacemos?, pues solo nos hace falta aplicar las ecuaciones de Steinhart–Hart, para ello utilizamos la siguiente formula:

\frac{1}{T}=\frac{1}{T0}+\frac{1}{B}*\ln \frac{R}{R0}

T –> Temperatura que queremos conocer (grados Kelvin)

T0–> Temperatura nominal de la NTC para esta NTC 25º

B –> Constante de la NTC para este modelo 3950

R –> Resistencia nominal de la NTC para este modelo 100K

R0 –> Resistencia que hemos calculado anteriormente

Una vez calculado el valor de T lo pasamos a grados centígrados simplemente restándole 273,15 y ya conocemos la temperatura de ambiente donde se encuentra la NTC

Si queremos saber el valor en grados Fahrenheit aplicamos la siguiente formula de conversión:

F=\frac{C*9}{5}+32

Conectando el termistor a Arduino

En este punto nos toca realizar el montaje final del divisor de tensión con el termistor a Arduino, para ello conectamos la salida VOut al pin A0 de Arduino y alimentamos nuestro divisor de tensión mediante la salida estabilizada de 3v3 que dispone Arduino Nano.

Conectamos la entrada Aref de Arduino a 3v3, con esta conexión le indicaremos a Arduino que el valor máximo del ADC (1023) corresponde a una tensión de 3v3.

analogReference(EXTERNAL);
Termistor divisor de tension arduino

Sensor de temperatura con Arduino y un termistor, el software de Arduino

Hora de implementar en Arduino toda la teoría que he explicado anteriormente, el sketch básico para leer la temperatura y mostrarla por la consola es el siguiente:

#define termistorPin A0
#define termistorNominalRes 100000
#define termistorNominalTemp 25
#define termistorBValue 3950
#define VoltageDividerResistor 100000
float termistorRes = 0.0;
float steinhart;
void setup() {
    Serial.begin(115200);
    analogReference(EXTERNAL);
}

void loop() {
  termistorRes = ((float)analogRead (termistorPin)* VoltageDividerResistor)/(1023 - (float)analogRead (termistorPin));
  steinhart = termistorRes / termistorNominalRes;     // (R/Ro)
  steinhart = log(steinhart);                         // ln(R/Ro)
  steinhart /= termistorBValue;                       // 1/B * ln(R/Ro)
  steinhart += 1.0 / (termistorNominalTemp + 273.15); // + (1/To)
  steinhart = 1.0 / steinhart;                        // Invert  
  steinhart -= 273.15;                                // convert to C
  Serial.print("Temperature "); 
  Serial.print(steinhart);
  Serial.println(" *C");
  delay(1000);
}

Podéis descargar el software dese mi repositorio en este link.

Manejo de Interrupciones en Arduino

Hay ocasiones en la que nos interesa que el flujo principal del programa este haciendo unas tareas y cuando se genera un evento pre-programado dejarlo todo para atender este evento, una vez atendido se continúa con la ejecución normal del programa, esto se consigue con el manejo de interrupciones en Arduino. Para estos casos existen las interrupciones, una característica de todos los microcontroladores incluido arduino.

Un ejemplo muy simple podría ser un simple motor, imaginemos que tenemos que controlar el giro de un motor y nos interesa saber cuándo el eje llega a una posición determinada en la tenemos instalado algún tipo de sensor, óptico, inductivo, capacitivo… este sensor nos dará un pulso justo cuando el eje este en la posición y es ese preciso momento que el software necesita conocer que el eje está en la posición, para este caso utilizaremos una interrupción por hardware.

También existen las llamadas interrupciones de software, este tipo de interrupciones están bastante limitadas en Arduino, la mayoría de microcontroladores te permiten activar por software algún Flag de interrupción para poder generar una interrupción cunado programamos el Software para reconocer alguna situación, lamentablemente en Arduino este tipo de interrupciones están limitadas a los timers, el timer0 ya dispone de una función específica para poder generar una interrupción cada x tiempo.

Interrupciones por Hardware

Según qué placa de desarrollo Arduino tengamos, dispondremos de más o menos pines con capacidad de interrupción, aquí pongo una tabla por modelo de placa de desarrollo y los pines de interrupción asociados:

ModeloINT0INT1INT2INT3INT4INT5
Mini23
Nano23
Uno23
Leonardo32017
Mega2321201918
DueTodos los pines
Definicion pines Arduino Interrupciones Pinout

A la hora de programar nuestra ISR (Interruption Service Routine) debemos tener en cuenta varias cosas:

  • El código ha de ser muy simple, activar alguna bandera, actualizar variable…. Durante el tiempo que se está ejecutando la ISR, el programa está parado, pudiendo llegar nuevas interrupciones las cuales no serían atendidas.
  • Las variables que se manipulen en la ISR se han de declarar como variables “volatile”
  • Las funciones de los timers como micros(), milis(), etc… dejan de dar servicio, esto es debido a que estas funciones también utilizan interrupciones y al estar tratando una interrupción, se desatiende el resto de interrupciones.

ISR es la rutina que realiza el manejo de interrupciones en Arduino, es una abreviacion generica dentro del mundo de la programacion.

¿Cómo se detecta una interrupción por Hardware?

Cuando hablamos de interrupciones por hardware, decimos que el micro ha de ser capaz de reconocer que en el pin asociado a la interrupción ha ocurrido algún evento que queremos controlar.El manejo de interrupciones en Arduino puede ser por Hardware o por Software (interrupcion que veremos mas tarde). Estos eventos pueden ser de 5 tipos:

  • FALLING, arduino detecta un flanco de bajada en el pin de interrupción
  • RISING, Arduino detecta un flanco de subida en el pin de la interrupción
  • CHANGE, Arduino detecta un cambio de estado en el pin de la interrupción
  • LOW, Arduino detecta el estado LOW en el pin de la interrupción
  • HIGH, Arduino detecta el estado HIGH en el pin de la interrupción

Para definir la interrupción, son necesarios 2 pasos, el primer paso es parametrizar la interrupción, es decir indicar el pin a controlar, el evento a controlar y la función que se ejecutará al reconocer la interrupción, el segundo paso es generar la propia ISR para tratar la interrupción.

attachInterrupt ( digitalPinToInterrupt (pin), ISR, mode );
  • pin –> pin donde recibimos el evento ( pin 2 o 3 para arduino nano)
  • ISR –> Nombre de la ISR donde se tratará la interrupción
  • mode –> FALLING, RISING, CHANGE, LOW o HIGH

Ejemplo de manejo de una Interrupción por Hardware

En un Arduino nano, conectaremos la salida de algún sensor al pin D2 de arduino, debemos conocer qué tipo de salida nos ofrece el sensor que conectamos, para este ejemplo imaginamos que el sensor nos da cero mientras está detectando y conectamos un led al Arduino en el pin D10. El circuito básico es el siguiente:

Esquematico Arduino interrupciones

Cada vez que el sensor detecte, activaremos el led y cuando no detecte, lo apagaremos.

int ledPin = 10;
int intSensorPin = 2;
volatile bool sensorStatus = false;

void setup()
{
  pinMode (ledPin, OUTPUT);
  pinMode(intSensorPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(intSensorPin), ISR_SENSOR, CHANGE);
}

void loop()
{
 if (sensorStatus){
  digitalWrite(ledPin, LOW);
 }else{
  digitalWrite(ledPin, HIGH);
 } 
}

void ISR_SENSOR (){
  if (digitalRead(2) == LOW)
  {
    sensorStatus = true;
  } else {
    sensorStatus = false;
  }
}

Tienes el software disponible aquí.

Interrupción por software Timer1

En el Tutorial para generar señales PWM con Arduino, vimos que los timers tienen varias funcionalidades, pueden actuar como temporizadores, contadores o generadores de señales PWM, en este apartado vermos una libreria muy simple para configurar nuestro TimerOne de Arduino y lincar la interrrupcion a su ISR correspondiente

Para este ejemplo vamos a conservar el mismo montaje y vamos a variar un poco el código, de manera que tendremos la interrupción por Hardware que activará el led y añadiremos una interrupción del Timer1 para que nos genere una interrupción cada 500ms ya haga parpadear el led cuando esté activado. Recordar que este Timer se utiliza para controlar servos, por lo que si programamos alguna interrupción de timer1, no será posible utilizar servos.

Para aprender a programar interrupciones de los 1 y 2 mira esta entrada donde te explico cómo hacerlo modificando los timers registros del Arduino.

  • Primero, debemos descargar e incluir la librería TimerOne.h
  • Segundo, cargamos el timer1 con el valor de los 500ms
  • Tercero asignamos el nombre de la ISR para esta interrupción
#include <TimerOne.h>
int ledPin = 10;
int intSensorPin = 2;
volatile bool sensorStatus = false;
volatile bool ledStatus = false;

void setup()
{
  pinMode (ledPin, OUTPUT);
  pinMode(intSensorPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(intSensorPin), ISR_SENSOR, CHANGE);

  Timer1.initialize (500000);
  Timer1.attachInterrupt (ISR_BlinkLed);
}

void loop()
{
 if (sensorStatus && !ledStatus){
  digitalWrite(ledPin, LOW);
 }else{
  digitalWrite(ledPin, HIGH);
 } 
}

void ISR_BlinkLed (){
   if (sensorStatus){
    if (ledStatus){
      ledStatus = false;
    } else {
      ledStatus = true;
    }
   }
 }

void ISR_SENSOR (){
  if (digitalRead(2) == LOW)
  {
    sensorStatus = true;
  } else {
    sensorStatus = false;
  }
}

Tienes disponible el codigo en mi repositorio

Tutorial para generar señales PWM con Arduino

Gracias por leer este Tutorial para generar señales PWM con Arduino, una señal PWM o Pulso con modulación puede ser implementado en arduino de diferentes maneras. En este artículo se explicará una simple técnica para generar un PWM directamente desde los registros, de esta manera se obtiene un mayor control de la frecuencia y el Duty cicle.

con modulación (PWM) puede ser implementado en arduino de diferentes maneras. En este artículo se explicará una simple técnica para generar un PWM directamente desde los registros, de esta manera se obtiene un mayor control de la frecuencia y el Duty cicle.

Pulso con modulación (PWM) puede ser implementado en arduino de diferentes maneras. En este artículo se explicará una simple técnica para generar un PWM directamente desde los registros, de esta manera se obtiene un mayor control de la frecuencia y el Duty cicle.

Para este ejemplo nos vamos a centrar en la placa de desarrollo Arduino nano, la cual incorpora un microcontrolador ATmega328

Que es un señal PWM?

Antes de continuar, vamos a ver que es una señal PWM y algunos posibles use cases.  Una señal PWM consta de dos parámetros fundamentales, que son: la frecuencia PWM y el ciclo de trabajo o duty cycle. Es posible generar señales PWM modificando cualquiera de estos parámetros, podemos mantener un Duty cicle fijo y variar la frecuencia entre en una frecuencia PWM mínima y una frecuencia PWM máxima o bien mantener una frecuencia fija e ir variando el Duty cicle de esta frecuencia.

PWM Duty Cicle

En este Tutorial generar señales PWM con Arduino, vamos a mantener una frecuencia fija e iremos variando el Duty cicle según nuestra necesidad,  con esta técnica de generación de señales PWM podemos dimear un simple LED, variar la velocidad de un motor, general señales de audio, etc… El objetivo final de esta técnica es aplicar una frecuencia de trabajo al elemento a controlar (por ejemplo un LED) y variando el ciclo de trabajo conseguimos variar el voltaje que se le suministra al LED en este caso. Consiguiendo un efecto dimmer en el LED.

Generación simple de señales PWM en Arduino

Arduino dispone de una función para la generación de una señal PWM de manera muy simple, esta funcion nos puede ser muy util si no necesitamos grandes requisitos, para ello se puede utilizar la función analogWrite (pin, dutuCycle).  En el parámetro pin le pasaremos el pin de arduino donde queremos generar la señal y el parámetro dutyCycle le pasaremos un valor entre 0 y 255 el cual corresponde con el porcentaje del duty cicle.

Los pines disponibles para generar una señal PWM en arduino nano son  (3, 5, 6, 9,10 y 11).

Definicion pines Arduino PWM Pinout

Siguiendo con el ejemplo del LED, vamos a hacer un dimmer, para ello conectamos un potenciómetro en el pin A0 y conectamos un led en el pin D3, mediante el potenciómetro podremos variar la intensidad del led.

Esquematico Arduino Led Dimmer

Como es habitual, se definen los pines de entrada y salida, y utilizamos la función analogRead () para generar nuestra señal PWM

int potenciometerPin = A0;    // select the input pin for the potentiometer
int ledPin = 3;               // select the pin for the LED
int potenciometerValue = 0;   // variable to store the value coming from the potenciometer

void setup() {
  
  pinMode(ledPin, OUTPUT);    // declare the ledPin as an OUTPUT:
}

void loop() {
 
  potenciometerValue = analogRead(potenciometerPin);   // read the value from the sensor
  analogWrite(ledPin, potenciometerValue / 4);          // Set PWM dutyCicle acording Potenciometer

}

Puedes descargar el codigo de este tutorial para generar señales PWM con Arduino desde mi repositorio

Con esta función es forma muy simple de generar una señal PWM, hay remarcar que no podemos variar la frecuencia PWM que ya viene pre-configurada en Arduino, en la tabla están las frecuencias PWM por defecto, si estas frecuencias no son adecuadas para nuestro propósito, existe una manera de variar la frecuencia a nuestra necesidad, se trata de manipular directamente los registros de configuración de Arduino para obtener la frecuencia y modo de funcionamiento que nos interese.

TimerDefault PWM Freq
Timer0490.20 Hz
Timer1976.56 Hz
Timer2490.20 Hz

Generar señales PWM mediante los registros de ATmega328  – ArduinoNano

Sigue leyendo este Tutorial para generar señales PWM con Arduino, para generar señales PWM, lo primero que se necesitan son los Timers, el Atmega328P dispone de 3 timers para generar hasta 6 salidas PWM. Cada uno de los 3 timers está asociado a dos pines de salida

TimerPinBitsUtilizacion
Timer06 y 58micros()
milis()
delay()
...
Timer19 y 1016Servos
Timer211 y 3 8Tone()

Cada Timer dispone de dos registros Output Compare, estos registros son los encargados de controlar las salidas PWM. Cuando el valor del Timer alcanza el valor del registro Output compare, su pin asociado cambiará de estado. Las dos salidas asociadas a cada Timer tendrán la misma frecuencia, pero el duty cicle podrá ser diferente.

Los timers utilizan la señal de reloj (Clock) de arduino y esta señal se pasa por un prescaler (1, 8, 64,256 o 1024) para los timers 0 y 1, y (1, 8, 32, 64, 128,256 o 1024) para el Timer 2.

La tabla siguiente muestra las salidas y pines asociados a los 6 registros Output Compare

TimerTimer OutputArduino Pin
Timer0OC0A6
OC0B5
Timer1OC1A9
OC1B10
Timer2OC2A11
OC2B3

Timer 2,  Registros asociados a la generación de señales PWM

Aunque los 3 timers que dispone el Atmega328 tienen algunas diferencias, el funcionamiento es prácticamente el mismo, en este apartado entraré en detalle en el timer2 y haremos el mismo ejemplo pero modificando los registros directamente, para los timer0 y timer1 mirar el datasheet para ver sus particularidades.

Una de los principales motivos por los cuales necesitaríamos modificar los registros es para poder ajuntar la frecuencia PWM. De manera predeterminada, Arduino ya la trae prefijada según el Timer o salida PWM que utilicemos.

Para poder generar una señal PWM, primero debemos configurar el modulo, en este caso el Timer 0,  la configuración de este Timer se realiza mediante los registros TCCR2A y TCCR2B.

Es este articulo no trataremos la gestion de las interrupciones, si quieres saber mas, mira esta entrada, para generar señales PWM, bajo mi punto de vista no es necesario añadir interrupciones, aunque cada uno es libre de hacer lo que crea oportuno.

TCCR2ACOM2A1COM2A0COM2B1COM2B0--WGM21WGM20
TCCR2BFOC2AFOC2B--WGM22CS22CS21CS20

COMA2:1  –> Configura la salida A (pin 11), invertida o no invertida

COMB2:1  –> Configura la salida B (Pin 3), invertida o no invertida

WGM20:2 –> Selecciona el modo de funcionamiento (Waveform Generation mode bit)

CS20:1 –> Selección del prescaler para la señal Timer Clock

FOC2A: B –> No utilizado en modo PWM, poner a 0

 Una vez configurado, se deben cargar los valores correspondientes a los duty cicle para que empiece la fiesta… los registros  son:

OCR2A y OCR2B.

Configuración de las salidas – Registros COM2A0:1 – COM2B0:1

La configuración de las salidas, depende del modo de funcionamiento que seleccionemos, básicamente podemos diferenciar entre 2 modos, Fast PWM y Phase Correct PWM, lo que hace esta configuración es seleccionar la polaridad de las salidas es decir, poner 0 o 1 cuando se alcanzan los valores de duty cicle, o dicho de otra manera, seleccionar el modo no invertido o modo invertido.

TCCR0A- Compare Output Mode, Fast PWM Mode
COM0A1COM0A0
00Normal port operation, OC0A disconnected.
01WGM02 = 0: Normal port operation, OC0A disconnected.
WGM02 = 1: Toggle OC0A on compare match.
10Clear OC0A on compare match (non-inverting mode).
11Set OC0A on compare match (inverting mode).
COM0B1COM0B0
00Normal port operation, OC0B disconnected.
01Reserved
10Clear OC0B on compare match, set OC0B at BOTTOM, (non-inverting mode).
11Set OC0B on compare match, clear OC0B at BOTTOM, (inverting mode).
TCCR0A- Compare Output Mode, Phase Correct PWM Mode
COM0A1COM0A0
00Normal port operation, OC0A disconnected.
01WGM02 = 0: Normal port operation, OC0A disconnected.
WGM02 = 1: Toggle OC0A on compare match.
10Clear OC0A on compare match when up-counting. Set OC0A on compare match when down-counting.
11Set OC0A on compare match when up-counting. Clear OC0A on compare match when down-counting.
COM0B1COM0B0
00Normal port operation, OC0B disconnected.
01Reserved
10Clear OC0B on compare match when up-counting. Set OC0B on compare match when down-counting.
11Set OC0B on compare match when up-counting. Clear OC0B on compare match when down-counting.

Modos de funcionamiento – Registros WGM20:2

Normal Mode – Non PWM:

                Este modo de funcionamiento requiere de interrupciones para un mejor control de la señal, el funcionamiento básico de este modo es que el registro contador de Timer  (TCNT2) se incrementa con cada Timer Clock, cuando el valor de TCNT2 alcanza 0xFF se genera una interrupción por overflow (TOV2), esta interrupción se ha de tratar por SW en su rutina correspondiente.  El contador del Timer TCNT2 vuelve a iniciar la cuenta desde 0x00.

Este modo de funcionamiento no se considera una operación PWM, ya que el Timer se utiliza como un mero contador

Clear Timer on Compare Mach (CTC) – Non PWM

Este modo es una evolución del normal mode, en el registro OCR2A se carga un valor de 8 bits que corresponde al porcentaje del duty cicle de la señal, el Contador del Timer (TCNT2) se incrementa con cada Timer Clock, una vez que TCNT2 alcanza el valor cargado en OCR2A, TCNT2 se resetea y comienza a contar de nuevo desde 0x00.

Este modo de funcionamiento no se considera una operación PWM, ya que este modo es un Timer o temporizador.

Fast PWM mode

Es el modo más simple de generar una señal PWM, el contador del Timer TCNT2 cuenta repetidamente desde 0x00  hasta 0xFF,  en el registro OCR2x se cargan los valores correspondientes al porcentaje del duty cicle, cuando el contador TCNT2 alcanza el valor cargado en OCR2x su salida cambia de estado en función si tenemos configurado el modulo como una salida no invertida o una salida invertida. Una vez el contador TCNT2 alcanza el valor 0xFF, este se resetea a 0x00 y la salida vuelve a cambiar de estado.

La fórmula para calcular la Frecuencia PWM  para el mode 3 es la siguiente:

                FPWM = Fosc / (N x (TOP +1))

                Fosc –> Frecuencia de oscilación (16Mhz en Arduino)

                N –> Valor prescaler

                TOP –> 0xFF

La fórmula para calcular la Frecuencia PWM  para el mode 7 es la siguiente:

                FPWM = (Fosc / (N x (TOP +1)))/2

                Fosc –> Frecuencia de oscilación (16Mhz en Arduino)

                N –> Valor prescaler

                TOP –> Valor del duty cicle (OCR2A)

Phase Correct PWM Mode

En este modo PWM, el contador TCNT2 se incrementa desde 0x00 hasta 0xFF con cada Timer Clock, una vez ha alcanzado 0xFF, el contador se decrementa hasta alcanzar 0x00 y vuelve a empezar repetidamente.

Durante la cuenta ascendente, la salida cambiará de estado cuando TCNT2 sea igual al valor de OCR2x y volverá a cambiar el estado de la salida cuando en la cuenta atrás los valores de TCNT2 y OCR2x vuelvan a coincidir.

La fórmula para calcular la Frecuencia PWM  para el mode 1 es la siguiente:

                FPWM = Fosc / (N x TOP)

                Fosc –> Frecuencia de oscilación (16Mhz en Arduino)

                N –> Valor prescaler

                TOP –> (0xFF * 2) –> 0x1FE –> 510 dec.

La fórmula para calcular la Frecuencia PWM  para el mode 5 es la siguiente:

                FPWM = (Fosc / (N x (TOP*2)))/2

                Fosc –> Frecuencia de oscilación (16Mhz en Arduino)

                N –> Valor prescaler

                TOP –> Valor del duty cicle (OCR2A)

Los modos de funcionamiento se pueden ver resumidos en la siguiente tabla:

ModeWGM22WGM21WGM20Modo de OperaciónValor TOP
0000Normal (Contador)0xFF
1001PWM Fase correct0XFF
2010CTC (Timer)OCRA
3011FAST PWMOxFF
4100Reserved-
5101PWM Fase correctOCRA
6110Reserved-
711FAST PWMOCRA

Selección del prescaler – CS20:1

En la siguiente tabla se muestra los posibles valores de prescaler para generar la señal Timer Clock, recordar que el Timer 2 tiene valores de prescaler diferentes.

CS22CS21CS20Descripcion
000Sin fuente de reloj - Timer stop
001Clk sin prescaler
010Clk prescaler 8
011Clk prescaler 32
100Clk prescaler 64
101Clk prescaler 128
110Clk prescaler 256
111Clk prescaler 1024

Manos a la obra!!!

Manteniendo el circuito con el potenciómetro y el led, vamos a modificar los registros de TMR2 para configurarlo de tal manera que genere una señal PWM y con el potenciómetro podamos dimear el Led.

Vamos a seleccionar el modo FAST PWM Mode 3, seleccionamos un valor de preescaler N=8 y configuramos las salidas como no invertidas.  Para esto se deben modificar los registros  TCCR2A y TCCR2B con los siguientes Valores:

TCCR2ACOM2A1COM2A0COM2B1COM2B0--WGM21WGM20
001011
TCCR2BFOC2AFOC2B--WGM22CS22CS21CS20
000010

Y en el registro OCR2B cargaremos el valor del duty cicle, los bits COM2A0-1 y el registro OCR2A, lo dejamos a cero ya son los que controlan el pin 11, y nosotros tenemos conectado el led al pin 3.

int potenciometerPin = A0;    // select the input pin for the potentiometer
int ledPin = 3;               // select the pin for the LED
int potenciometerValue = 0;   // variable to store the value coming from the potenciometer

void setup() {
pinMode(ledPin, OUTPUT);    // declare the ledPin as an OUTPUT
  TCCR2A = 0;
  TCCR2B = 0;

  TCCR2A |= ( 0 << COM2A1);
  TCCR2A |= ( 0 << COM2A0);
  TCCR2A |= ( 1 << COM2B1);
  TCCR2A |= ( 0 << COM2B0);
  TCCR2A |= ( 1 << WGM21);
  TCCR2A |= ( 1 << WGM20);
  
  TCCR2B |= (0 << FOC2A);
  TCCR2B |= (0 << FOC2B);
  TCCR2B |= (0 << WGM22);
  TCCR2B |= (0 << CS22); 
  TCCR2B |= (1 << CS21); 
  TCCR2B |= (0 << CS20); 
  
  TCNT2  = 0;
  OCR2A = 0;
}

void loop() {
  potenciometerValue = analogRead(potenciometerPin);   // read the value from the sensor
  OCR2A = potenciometerValue/4;
}

Descargate el codigo en este link.

CNC, La electronica

La electrónica de este CNC está basada en una placa arduino uno con el software GRBL 1.1 instalado. A nivel de HW consta del Arduino Uno, los drivers para los motores de pasos, fuentes de alimentación, algún regulador PWM para los Spindlers y un módulo Bluetooth para poder conectarme desde el PC. Adicionalmente le instalé una Raspberry Pi para poder operar el CNC insitu.

Los drivers de los motores de pasos pueden ser cualquiera de los que comercialmente se venden, solo hay que asegurar que serán capaces de aguantar la intensidad que consuma el propio motor.  Yo opté por instalar 2 motores de pasos en los ejes X e Y, por lo que el consumo de intensidad es el doble, y debido a esto tome la decisión de instalar unos drivers de 3A basados en el TB6560, son más que suficientes para controlar un par de motores de 0,5A y por otro lado ya tengo la electrónica dimensionada para futuros proyectos donde requiera motores más grande tipo Nema 23 o Nema 34.

Los finales de carrera, son sensores inductivos de 8mm de diámetro, al instalar este tipo de sensor, es necesaria una fuente de alimentación o instalar algún tipo de DC-DC que nos proporcione una alimentación de 6V para alimentar este tipo de sensor. Hay que decir que la instalación de finales de carrera no es obligada, aunque yo personalmente lo recomiendo. Tampoco es obligado instalar este tipo de sensores, se pueden instalar unos finales de carrera mecánicos como los de toda la vida, si escoges esta opción, no es necesario el DC-DC ya que los finales de carrera nos darán 0 cuando sean alcanzados.

En esta tabla tenéis el ruteado de las conexiones entre la placa Arduino, los drivers, sensores, pulsadores etc…

Señal Pin Arduino Uno Tipo Destino
Reset A0 IN Pulsador
Feel Hold A1 IN Pulsador
Start A2 IN Pulsador
Coolant Enable A3 OUT Rele
       
Probe A5 IN Entrada Sonda
       
Step X D2 OUT Driver X
Step Y D3 OUT Driver Y
Step Z D4 OUT Driver Z
Dieccion X D5 OUT Driver X
Direccion Y D6 OUT Driver Y
Direccion Z D7 OUT Driver Z
       
Stepper Enable D8 OUT Driver X,Y,Z
Limite X D9 IN Salida Sensor inductivo
Limite Y D10 IN Salida Sensor inductivo
PWM Spindle – Laser D11 OUT Salida PWM 3Khz
Limite Z D12 IN Salida Sensor inductivo
Spindle Direcion D13 OUT Direccion giro

El modulo Bluetooth, es una simple pasarela Bt–>Uart conectada directamente a los pines Rx y Tx del Arduino, basta con emparejar el BT con el PC y seleccionar el Puerto serie correspondiente para poder comunicarnos con la máquina.  Tener en cuenta que las conexiones son cruzadas, es decir el pin Rx de Arduino, irá conectado al pin Tx del módulo bluetooth y el pin Tx del Arduino irá conectado al pin Rx del Bluetoth.

La instalación de la Raspberry PI, no tiene más, lo único que nos debemos asegurar es conectar la Rasberry Pi con el Arduino mediante un cable USB para poder conectar con la maquina e instalar el SW de control GRBL que más nos guste.

Router CNC / Laser CNC

Uno de los primeros proyectos que desarrollé en 3D fue un pequeño CNC muy funcional. El diseño esta hecho en Fusion 360 de Autodesk, un SW con un uso muy intuitivo.  Este CNC está diseñado para utilizar perfilería de aluminio 2020, muy versátil, económica y fácil de localizar en el mercado.

Una de las principales características es la posibilidad de variar las dimensiones del área de trabajo con relativamente pocos cambios, solo es necesario ampliar los perfiles, la guía lineal y la correa.

Todas las estructuras necesarias para la construcción de este CNC se pueden imprimir con una impresora 3D de sobremesa, al final de esta página están los enlaces para descargar los modelos y poder imprimirlos. Yo suelo imprimir en ABS, aunque cada cual es  muy libre de imprimir en el material que más le guste.

Otra de las características de esta máquina CNC es su capacidad multifunción para realizar varias operaciones, en función de la herramienta que se instale en el eje Z puede realizar una tarea u otra.  En el eje Z se pueden instalar un pequeño laser, una pequeña fresadora y un pequeño taladro.

Como productos, con este diseño, se pueden realizar impresiones laser sobre materiales como madera, cuero, cristales, piedra, corte laser de materiales blandos como cartón, papel, goma eva, etc… Como fresadora, hay que tener en cuenta las limitaciones mecánicas del diseño, no hay que olvidar que los soportes de fijación son piezas impresas en plástico con  todo lo que conlleva, algunos de los materiales que se pueden fresar es madera, hace uso grabados impresionantes, y con la velocidad y herramienta adecuada se puede grabar y fresar aluminio.

El soporte multifunción.

El soporte multifunción es una de las piezas más importantes de este CNC, esta pieza tiene una doble función, por un lado la utilizo para fijar la perfileria de aluminio y por el otro sirve para la fijación del motor de pasos o para instalar un tensor de correa.

Puedes descargar el modelo listo para imprimir en este enlace.

La ubicación del motor puede ser por ambos lados y está pensada para alojar motores nema 17 con una polea GT02.

Por el otro lado se puede instalar un sistema de tensor de correa, para ello diseñé el tensor donde se monta una polea ciega GT2 y la tapa donde se instala un tornillo para poder regular la tensión de la correa.

En imprimir un solo soporte en la 3D se tarda alrededor de 5 horas, con un relleno del 80%, ármate de paciencia que se necesitan 6 piezas ¡!

Continua con la electronica del CNC