Archivo de la categoría: Proyectos

Sintonizador de radio con RDS

Propósito:

Construir un receptor de radio FM con RDS.

Material necesario

Tengo que reconocer que mi experiencia con el si4703 es algo agridulce, aunque no sé si es debida a mi placa o es algo generalizado.

Tras no conseguir que funcionara ni con la Raspberry ni con el Nodemcu esp8266 adquirí esta Placa Arduino UNO, en la que funcionó sin problemas… más o menos.

Conexiones:

si4703

RST -> pin 2

SDIO -> A4

SCLK -> A5

3.3 v ->

GND -> G

La diferencia fundamental respecto al TA5767 es que el si4703 decodifica el RDS, pero no dispone de conector de antena. Esta se suple con el cable de los auriculares, como en muchas radios de bolsillo.

El script utilizado es este, que usa la libería SI4703, y es válido también para otros sintonizadores.

El menú se muestra en el monitor serie de Arduino, con las opciones disponibles:

Para sintonizar una emisora concreta, por ejemplo en los 104.0 Mhz, hay que escribir f10400

Este es el aspecto que presenta el monitor serie con la información de la emisora sintonizada.

Fuente:

https://github.com/mathertel/Radio/blob/master/examples/ScanRadio/ScanRadio.ino

Sintonizador de radio FM

Propósito:

Construir un receptor de radio FM con una pequeña pantalla OLED. También vamos a aprender a usar el monitor serie de Arduino para enviar datos y no solo para recibirlos.

Dificultad:

Fácil.

Material necesario

Conexiones:

Pantalla OLED:

GND->G

VCC->3V

SCL->D4

SDA->D3

TEA5767:

SCL -> D1

SDA -> D2

5v -> 3v (yo lo he conectado a 3 voltios y funciona correctamente)

GND -> G

El script es este, y controla la radio a través del monitor serie. Los comandos disponibles aparecen en este. Para sintonizar una emisora concreta se escribe f seguido de la frecuencia, multiplicada por 100.

f10400 por ejemplo sintoniza los 104.0 MHz, y se muestra en la pantalla.

Si no disponemos de pantalla, el script es este.

Conclusión:

Es fácil y vistoso construir un receptor de radio FM estéreo con la placa TEA5767.

Fuente:

http://www.mathertel.de/Arduino/RadioLibrary.aspx

Estación meteorológica local

Propósito:

Montar una estación meteorológica que proporciona datos locales de temperatura, presión, humedad y luminosidad que se pueden consultar a través de la red.

Material necesario

Dificultad:

  • Fácil

Tenemos que tener instaladas las librerías

ESP8266WebServer.h
Wire.h
Adafruit_Sensor.h
BME280I2C.h
BH1750.h

Conexiones:

El cableado es sencillo, ya que es idéntico en ambos sensores:

GND – > G

VCC -> 3v

SDA -> D2

SDL -> D1

El código es este

Simplemente se trata de leer los datos de temperatura, presión, humedad y luminosidad de los sensores BME280 y GY-30, respectivamente, y enviarlos a una página web. Un miniservidor se encarga de que esta se pueda hacer visible.

En el Monitor serie podemos comprobar la dirección IP donde están disponibles los datos, que es la de la placa nodemcu, al tiempo que comprobamos que se inicia correctamente el servidor web.

Conclusión

Solo con dos sensores, algunos cables y una placa nodemcu se puede montar una completa estación meteorológica y consultar los datos a través de una página web.

Configurar una torretbox

Propósito:

Programar la Raspberry para la descarga de archivos Torrent.

Una Raspberry se caracteriza por un bajo consumo eléctrico, por lo que se puede tener mucho tiempo encendido sin que suponga un gasto de energía excesivo. Por tanto puede ser interesante montar en una de ellas un servidor para la transferencia de torrents, siempre por supuesto de material no sujeto a la normativa de derechos de autor.

Material necesario:

Aunque la Raspberry se puede conectar a la red mediante WIFI, es mejor contar con una red cableada para mejorar las velocidades de transferencia.

Dificultad:

  • Facil

Damos por hecho que nuestra Raspeberry está correctamente configurada y disponemos de acceso mediante SSH. Si no, procedemos como se indica en esta entrada.

Comenzamos instalando el programa transmission, que es muy conocido en el ámbito Linux.

sudo apt-get install -y transmission-daemon transmission-cli transmission-common

Seguimos con su configuración. Para ello detenemos el servicio, que ya se ha iniciado automáticamente.

sudo service transmission-daemon stop

Vamos al directorio donde está instalado:

cd /etc/transmission-daemon

Y editamos el archivo de configuración, en el que hay que cambiar algunas cosas:

sudo nano settings.json

Indicar en qué carpeta queremos que se alojen las descargas:

«download-dir»: «/lacarpetaquesea»,

Tal cual, con comillas y coma al final.

«incomplete-dir-enabled»: true,

que permite usar un directorio para las descargas incompletas, que también hay que indicar

«incomplete-dir»: «/directoriodedescargasincompletas»,

Yo aconsejo alojar tanto el directorio download-dir como incomplete-dir fuera de la tarjeta micro SD si los archivos que se van a descargar son grandes. Lo adecuado sería que estén en un disco duro externo.

La única dificultad es que ambas carpetas deben tener los permisos adecuados para que sea posible leer y escribir en ellas.

«rpc-password»: «nuestracontraseñadeacceso»,

«rpc-username»: «nuestronombredeusuario»,

«rpc-whitelist-enabled»: false,

para poder acceder desde cualquier ordenador

«speed-limit-down»: 1900,
«speed-limit-down-enabled»: true,

«speed-limit-up»: 900,
«speed-limit-up-enabled»: true,

Con esto, ya podemos acceder a nuestra página de descargas, a través de la IP de la Raspberry y el puerto 9091

Para comenzar a descargar subimos el archivo torrent mediante el botón de la izquierda y a correr.

Fuentes:

Transmission en una Raspberry Pi. La forma más inteligente de descargar Torrents.

Conclusión:

Es posible configurar la Raspberry como dispositivo de un relativo bajo coste y escaso consumo para compartir archivos en la Red.

FT232RL FTDI Mini USB a TTL y nodemcu

Propósito:

Recuperar completamente una placa Esp8266 con el conector micro USB roto.

Material necesario:

  • Nodemcu con el  puerto USB  roto
  • Placa FT232RL FTDI Mini USB a TTL
  • Un cable mini USB

Dificultad:

  • Muy fácil

Algunas veces ocurre un desastre, y tiene solución.

El conector microUSB del nodemcu saltó, simplemente, con lo que la placa quedó inservible, sin que fuera posible alimentarla ni programarla… hasta que el FT232RL FTDI Mini USB a TTL vino en nuestra ayuda.

Esta pequeña placa, precisamente, permite la conexión y la programación, con un cableado muy sencillo.

Conexiones:

FTDI – Nodemcu

RX -> TX

TX -> RX

VCC -> VIN

GND -> G

Se conecta mediante un cable mini USB, y ya tenemos nuestro nodemcu recuperado.

El único inconveniente es que, cuando queramos cargar el firmware tendremos que pulsar, en este orden, los botones RST, FLASH y soltarlos ambos a la vez, justo cuando desde el IDLE de Arduino indica Connecting…

Si no funcionara habría que repetir la operación hasta conseguirlo.


Fuente:

https://www.instructables.com/NODEMcu-Usb-Port-Not-Working-Upload-the-Code-Using/

Conclusión:

Es posible recuperar una placa nodemcu con el puerto USB roto con una solución sencilla y relativamente barata.

Mini estación meteorológica Raspberry

Propósito:

Construir una estación metereológica basada en los sensores BME280 y BH1750 local que envía datos a un servidor externo.

Un proyecto interesante es una estación meteorológica que envía los datos de presión, temperatura, humedad e iluminación a un servidor externo para proporcionar una gráfica, en este caso Thingspeak.

También puede servir para ver cómo funciona el internet de las cosas o IoT.

Material necesario

Dificultad:

  • Fácil

Conexiones:

Comenzamos conectando los sensores BME280 y BH1750. El esquema es el mismo:

SDA -> GPIO SDA1

SCL ->  GPIO SCL1

GND -> GND

VCC -> 3.3V

Comenzamos comprobando si está activado el driver i2c.

dmesg | grep i2c

En caso contrario, tendremos que activarlo con

sudo raspi-config

Vamos a 9 Advanced Options

Bajamos hasta A7 I2C

Y lo activamos.

Instalamos algunos paquetes

sudo apt-get install i2c-tools python-pip

Hacemos lo mismo con Python, en su versión 2 o 3:

sudo python setup.py install

sudo python3 setup.py install

E instalamos la librería RPi.bme280

sudo pip install RPi.bme280

Comprobamos el correcto funcionamiento con el siguiente script:

#!/usr/bin/python
#--------------------------------------
#    ___  ___  _ ____
#   / _ \/ _ \(_) __/__  __ __
#  / , _/ ___/ /\ \/ _ \/ // /
# /_/|_/_/  /_/___/ .__/\_, /
#                /_/   /___/
#
#           bme280.py
#  Read data from a digital pressure sensor.
#
#  Official datasheet available from :
#  https://www.bosch-sensortec.com/bst/products/all_products/bme280
#
# Author : Matt Hawkins
# Date   : 25/07/2016
#
# http://www.raspberrypi-spy.co.uk/
#
# Modified for personal use by
# https://github.com/bortek
# 
#--------------------------------------
import smbus
import time
from ctypes import c_short
from ctypes import c_byte
from ctypes import c_ubyte
import datetime

# Humidity  & temp adjustment value. Positive value will be added.
# Negative will be substracted
humidity_adj = +0
temperature_adj = +0

DEVICE = 0x76 # Default device I2C address


bus = smbus.SMBus(1) # Rev 2 Pi, Pi 2 & Pi 3 uses bus 1
                     # Rev 1 Pi uses bus 0

def getShort(data, index):
  # return two bytes from data as a signed 16-bit value
  return c_short((data[index+1] << 8) + data[index]).value

def getUShort(data, index):
  # return two bytes from data as an unsigned 16-bit value
  return (data[index+1] << 8) + data[index]

def getChar(data,index):
  # return one byte from data as a signed char
  result = data[index]
  if result > 127:
    result -= 256
  return result

def getUChar(data,index):
  # return one byte from data as an unsigned char
  result =  data[index] & 0xFF
  return result

def readBME280ID(addr=DEVICE):
  # Chip ID Register Address
  REG_ID     = 0xD0
  (chip_id, chip_version) = bus.read_i2c_block_data(addr, REG_ID, 2)
  return (chip_id, chip_version)

def readBME280All(addr=DEVICE):
  # Register Addresses
  REG_DATA = 0xF7
  REG_CONTROL = 0xF4
  REG_CONFIG  = 0xF5

  REG_CONTROL_HUM = 0xF2
  REG_HUM_MSB = 0xFD
  REG_HUM_LSB = 0xFE

  # Oversample setting - page 27
  OVERSAMPLE_TEMP = 2
  OVERSAMPLE_PRES = 2
  MODE = 1

  # Oversample setting for humidity register - page 26
  OVERSAMPLE_HUM = 2
  bus.write_byte_data(addr, REG_CONTROL_HUM, OVERSAMPLE_HUM)

  control = OVERSAMPLE_TEMP<<5 | OVERSAMPLE_PRES<<2 | MODE
  bus.write_byte_data(addr, REG_CONTROL, control)

  # Read blocks of calibration data from EEPROM
  # See Page 22 data sheet
  cal1 = bus.read_i2c_block_data(addr, 0x88, 24)
  cal2 = bus.read_i2c_block_data(addr, 0xA1, 1)
  cal3 = bus.read_i2c_block_data(addr, 0xE1, 7)

  # Convert byte data to word values
  dig_T1 = getUShort(cal1, 0)
  dig_T2 = getShort(cal1, 2)
  dig_T3 = getShort(cal1, 4)

  dig_P1 = getUShort(cal1, 6)
  dig_P2 = getShort(cal1, 8)
  dig_P3 = getShort(cal1, 10)
  dig_P4 = getShort(cal1, 12)
  dig_P5 = getShort(cal1, 14)
  dig_P6 = getShort(cal1, 16)
  dig_P7 = getShort(cal1, 18)
  dig_P8 = getShort(cal1, 20)
  dig_P9 = getShort(cal1, 22)

  dig_H1 = getUChar(cal2, 0)
  dig_H2 = getShort(cal3, 0)
  dig_H3 = getUChar(cal3, 2)

  dig_H4 = getChar(cal3, 3)
  dig_H4 = (dig_H4 << 24) >> 20
  dig_H4 = dig_H4 | (getChar(cal3, 4) & 0x0F)

  dig_H5 = getChar(cal3, 5)
  dig_H5 = (dig_H5 << 24) >> 20
  dig_H5 = dig_H5 | (getUChar(cal3, 4) >> 4 & 0x0F)

  dig_H6 = getChar(cal3, 6)

  # Wait in ms (Datasheet Appendix B: Measurement time and current calculation)
  wait_time = 1.25 + (2.3 * OVERSAMPLE_TEMP) + ((2.3 * OVERSAMPLE_PRES) + 0.575) + ((2.3 * OVERSAMPLE_HUM)+0.575)
  time.sleep(wait_time/1000)  # Wait the required time  

  # Read temperature/pressure/humidity
  data = bus.read_i2c_block_data(addr, REG_DATA, 8)
  pres_raw = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4)
  temp_raw = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4)
  hum_raw = (data[6] << 8) | data[7]

  #Refine temperature
  var1 = ((((temp_raw>>3)-(dig_T1<<1)))*(dig_T2)) >> 11
  var2 = (((((temp_raw>>4) - (dig_T1)) * ((temp_raw>>4) - (dig_T1))) >> 12) * (dig_T3)) >> 14
  t_fine = var1+var2
  temperature = float(((t_fine * 5) + 128) >> 8);

  # Refine pressure and adjust for temperature
  var1 = t_fine / 2.0 - 64000.0
  var2 = var1 * var1 * dig_P6 / 32768.0
  var2 = var2 + var1 * dig_P5 * 2.0
  var2 = var2 / 4.0 + dig_P4 * 65536.0
  var1 = (dig_P3 * var1 * var1 / 524288.0 + dig_P2 * var1) / 524288.0
  var1 = (1.0 + var1 / 32768.0) * dig_P1
  if var1 == 0:
    pressure=0
  else:
    pressure = 1048576.0 - pres_raw
    pressure = ((pressure - var2 / 4096.0) * 6250.0) / var1
    var1 = dig_P9 * pressure * pressure / 2147483648.0
    var2 = pressure * dig_P8 / 32768.0
    pressure = pressure + (var1 + var2 + dig_P7) / 16.0

  # Refine humidity
  humidity = t_fine - 76800.0
  humidity = (hum_raw - (dig_H4 * 64.0 + dig_H5 / 16384.0 * humidity)) * (dig_H2 / 65536.0 * (1.0 + dig_H6 / 67108864.0 * humidity * (1.0 + dig_H3 / 67108864.0 * humidity)))
  humidity = humidity * (1.0 - dig_H1 * humidity / 524288.0)
  if humidity > 100:
    humidity = 100
  elif humidity < 0:
    humidity = 0

  return temperature/100.0,pressure/100.0,humidity

def main():

  (chip_id, chip_version) = readBME280ID()
#  print "Chip ID     :", chip_id
#  print "Version     :", chip_version

  temperature,pressure,humidity = readBME280All()

  if datetime.date.today().year != 1970:
    print ("{} {:0.1f} {:0.1f} {:0.2f}".format(datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S'),humidity + humidity_adj,temperature + temperature_adj,pressure))

#  print "Temperature : ", temperature, "C"
#  print "Pressure : ", pressure, "hPa"
#  print "Humidity : ", humidity, "%"

if __name__=="__main__":
   main()

Claro, que también lo podemos instalar así

wget -O bme280.py http://bit.ly/bme280py

o así:

wget https://bitbucket.org/MattHawkinsUK/rpispy-misc/raw/master/python/bme280.py

Si da error, instalamos la librería smbus

pip install smbus o pip3 install smbus (en su caso)

ejecutando

python bme280.py

debe aparecer

(debería también dar datos de humedad… si fuera un bme280. En mi caso me temo que sea un bmp280).

También comprobamos el funcionamiento del sensor de luminosidad, con un script que se puede descargar de aquí:

https://gist.github.com/oskar456/95c66d564c58361ecf9f

En este caso, el resultado es este.

Ya que tenemos los sensores funcionando, nos creamos una cuenta gratuita en https://thingspeak.com/.

Con este script leemos los datos de los sensores y los enviamos periódicamente a https://thingspeak.com/, con este resultado:

También presenta los datos en pantalla:

Fuentes:

https://pypi.org/project/RPi.bme280/

Using the BH1750FVI I2C Digital Light Sensor

Conclusión:

Una raspberry puede ser el «corazón» de una estación meteorológica con unos sensores adecuados.

Estación meteorológica

Propósito:

Programar una placa nodemcu Esp8266 para que se conecte a un servidor meteorológico y proporcione los datos locales de forma gráfica.

Un proyecto muy sencillo es una estación meteorológica que se conecta con un servidor de tiempo para darnos los datos locales y la previsión.

Nuestra placa nodemcu debe estar configurada previamente como se explica aquí, y funcionando correctamente.

Material necesario

También hay kits que incluyen todo el material necesario

Dificultad:

  • Fácil

https://youtu.be/RIC8dfXzEGY

Es un proyecto realmente sencillo y vistoso, que no tiene más dificultad que conectar adecuadamente la pantalla OLED.

Dentro de Arduino, debemos descargar la librería (Herramientas -> Administrar las bibliotecas) ESP8266 Weather Station.

Una vez instalada dentro de los ejemplos podemos encontrar el código necesario en Archivo -> Ejemplos -> ESP8266 Weather Station -> WeatherStationDemo.

En este código solo tenemos que cambiar

const char* WIFI_SSID = «NOMBREDENUESTROAP»;
const char* WIFI_PWD = «CLAVEDENUESTROAP»;

Para la descarga de los datos meteorológicos nos vamos a

https://docs.thingpulse.com/how-tos/openweathermap-key/

donde nos inscribimos gratuitamente para obtener la clave de la API, que escribimos aquí:

String OPEN_WEATHER_MAP_APP_ID = «LACLAVEQUENOSHANDADOENOPENWEATHERMAP»;

Y nuestra localización, que es un código que también conseguimos ahí.

String OPEN_WEATHER_MAP_LOCATION_ID = «ELCÓDIGODENUESTRALOCALIZACIÓN»;

También lo podemos poner en español:

String OPEN_WEATHER_MAP_LANGUAGE = «es»;

Conexiones:

La conexión de la pantalla OLED es la siguiente, tal como se ve en el vídeo:

GND->G

VCC->3V

SCL->D4

SDA->D3

Subimos el programa a la tarjeta, pulsando en botón de la flecha hacia la derecha (segundo por la izquierda), y veremos el efecto que se aprecia en el vídeo.

Muy fácil.

Conclusión:

Es un proyecto sencillo y vistoso para aprender el funcionamiento de Arduino y de la placa Esp8266.

 

Sistema de videovigilancia

Propósito:

Construir un sistema de videovigilancia experimental sencillo y de bajo coste.

Material necesario:

Dificultad:

  • Media

Para montar este sistema necesitamos una cámara, preferiblemente infrarroja, como por ejemplo esta:

Es infrarroja, por lo que captará imágenes incluso en condiciones de baja iluminación.

Conexiones:

Comenzamos conectando la cámara a a la Raspberry. El lado impreso de la cinta debe mirar a los puertos USB, mientras que en la cámara debe ser al revés.

Nota. Asumimos que el sistema operativo está instalado, tal como se explica en esta entrada, y que disponemos de acceso SSH, como se indica aquí.

Entramos mediante SSH y tecleamos

sudo raspi-config

Y habilitamos la cámara, en Interfacing Options

Comprobamos su funcionamiento haciendo una foto, que se guarda en el escritorio

raspistill -o Desktop/image.jpg

Si obtenemos algún error, posiblemente se deba a que el cable no está bien conectado, por lo que tendremos que revisarlo.

Envío de correo cuando se detecta movimiento

En un sistema de videovigilancia es básica la monitorización. Este sistema manda un correo a una cuenta de gmail cada vez que se detecta un movimiento, además de un vídeo.

Para ello tendremos que habilitar el acceso a dicha cuenta de aplicaciones no seguras, como la nuestra, por lo que no es mala idea crear una específica para este menester.

Comenzamos creando un programa denominado emailip.py en el directorio background que hemos creado previamente

cd ~

#create background folder

mkdir background

#create python script

sudo nano emailip.py

El contenido del programa es el siguiente:

#write in emailip.py

import socket

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

s.connect((«8.8.8.8», 80))

print(s.getsockname()[0])

x = s.getsockname()[0]

s.close()

import smtplib

from email.mime.multipart import MIMEMultipart

from email.MIMEText import MIMEText

fromaddr = «YOUR ADDRESS»

toaddr = «RECEIVING ADDRESS»

msg = MIMEMultipart()

msg[‘From’] = fromaddr

msg[‘To’] = toaddr

msg[‘Subject’] = «IP Address»

body = xmsg.attach(MIMEText(body, ‘plain’))

server = smtplib.SMTP(‘smtp.gmail.com’, 587)

server.starttls()

server.login(fromaddr, «YOUR PASSWORD»)

text = msg.as_string()

server.sendmail(fromaddr, toaddr, text)

server.quit()

Este es el archivo completo, donde lógicamente hay que introducir los datos de nuestra cuenta de Gmail.

Nota: es conveniente que no usemos nuestra cuenta de correo principal porque para poder acceder debemos configurar opciones en Gmail que limitan la seguridad de la misma.

emailip.py

Reiniciamos con

sudo reboot

y modificamos el archivo /etc/rc.local

sudo nano /etc/rc.local

añadiendo las siguientes líneas:

while ! /sbin/ifconfig wlan0 | grep -q ‘inet addr:[0-9]’;

do sleep 3

done

_IP=$(hostname -I) || true

if [ «$_IP» ]; then

printf «My IP address is %s\n» «$_IP»

python /home/pi/Background/emailip.py &

fi

exit 0

Instalamos el programa motion

sudo apt install motion

Y editamos el programa motion para que el programa arranque con la Raspberry

sudo nano /etc/default/motion

Y para ello cambiamos start_motion_daemon=no por

start_motion_daemon=yes

Lo iniciamos como servicio

sudo service motion start

Y comprobamos que funciona, accediendo desde la misma Raspberry, directamente o a través de VNC, en la dirección

localhost:8081

Tendremos que cambiar algunos parámetros en el archivo de configuración motion.conf,

sudo nano /etc/motion/motion.conf

por ejemplo:

daemon on

stream_localhost off

webcontrol_localhost off

ffmpeg_output_movies on

target_dir /var/lib/motion

##################

#local web browser streaming options

##################

stream_maxrate 100 #This will allow for real-time streaming but requires more bandwidth & resources

framerate 60 #This will allow for 60 frames to be captured per second #the higher this gets, the slower the video processing

width 640 #This changes the width of the image displayed

height 480 #This changes the height of the image displayed

##################

#emailing video settings in …/motion.conf

##################

En las siguientes líneas, se borra el ; del inicio de la misma, y se dejan de este modo:

on_event_start python /home/pi/background/motionalert.py %f

on_movie_end python /home/pi/background/motionvid.py %f

Cargamos las modificaciones

sudo service motion reload

Y funciona!!!

Ya solo queda meter todo el sistema en un recipiente hermético para que lo podamos poner a la intemperie.

No cabe duda que esta solución es imaginativa, aunque no sé si será demasiado eficaz.


Conclusión:

Se puede crear un sistema de videovigilancia sencillo con una cámara y una Raspberry. La mayor dificultad consiste en acceder a Gmail para que pueda enviar los mensajes, para lo cual hay que cambiar las opciones de seguridad de la cuenta.

Fuentes:

https://medium.com/swlh/night-vision-camera-for-raspberry-pi-4db1686cb465

Video Vigilancia con el Raspberry Pi

https://jeremyblythe.blogspot.com/2012/06/motion-google-drive-uploader-and.html

Sistema de videovigilancia con detector de movimiento Motion

https://omes-va.com/como-instalar-opencv-en-raspberry-pi/

https://github.com/HackerShackOfficial/Smart-Security-Camera.git

https://www.instructables.com/Raspberry-Pi-Motion-Detection-Security-Camera/#step3

Un NAS de andar por casa

Propósito:

Construir un servidor de archivos accesible desde una red local, aprovechando, en su caso, algún disco duro sobrante procedente de cambios u ordenadores desechados, aunque por supuesto también se pueden usar discos duros nuevos.

Material necesario:

Material opcional:

Dock con dos bahías, con conexión USB 3.0

Disco duro externo Western Digital de 4 tb USB 3.0:

Dificultad:

  • Media

Un NAS, o servidor de almacenamiento, no es más que un disco duro conectado a una red al cual podemos acceder desde cualquier ordenador de la misma. De esta forma compartiremos el almacenamiento, copiando o moviendo archivos, e incluso reproducirlos en otro dispositivo, por ejemplo una Smart TV.  Así dicho almacenamiento no estará limitado a un ordenador en concreto.

Bien es cierto que algo parecido lo podemos conseguir compartiendo una unidad de almacenamiento interna o externa, pero de ese modo obligamos a que el ordenador al cual está conectada se encuentre encendido permanentemente, puesto que en caso contrario no se tendría acceso a la misma.

En el mercado hay un gran número de NAS, aunque por lo general no son baratos. Es importante no confundirlos con un disco duro externo, aunque se parezcan en algunos casos. Un NAS debe conectarse directamente a la red, mejor a través de un puerto giga ethernet.

Nuestra Raspberry también puede convertirse en un NAS. En mi caso, complementada con un dock con dos bahías, con conexión USB 3.0. Una forma, también, de aprovechar esos discos duros que acaban guardados en un cajón. O de convertir en disco duro de red cualquier disco externo que no disponga de esa funcionalidad.

Para conseguir que nuestra Raspberry cumpla la función de NAS podemos instalar SAMBA, que no es demasiado amigable u Open Media Vault, un software muy completo y algo más fácil de configurar.

Por rendimiento, es recomendable utilizar una Raspberry Pi 4 conectada mediante cable aunque también funciona a través de la WIFI, y por razones de compatibilidad una tarjeta micro SD con una instalación fresca del SO. Una vez configurada correctamente accedemos mediante SSH y actualizamos el software.

sudo apt update && sudo apt -y upgrade

e instalamos Open Media Vault

wget -O – https://github.com/OpenMediaVault-Plugin-Developers/installScript/raw/master/install | sudo bash

Comprobamos que se ha instalado correctamente accediendo a la dirección IP de la Raspberry desde el navegador, donde deberemos encontrar la pantalla de acceso y podremos cambiar el idioma de la aplicación.

El usuario inicial es admin y la contraseña openmediavault.

Comenzamos cambiando la contraseña al usuario admin por otra que nos guste.

El menú de la izquierda tiene numerosas opciones, pero nos vamos a centrar en las más básicas:

Almacenamiento -> Discos

Nos muestra los discos conectados, incluyendo la tarjeta micro SD del SO.

Almacenamiento -> Sistema de archivos

Las particiones existentes en esos discos

Permisos de acceso -> Usuarios

Permite crear usuarios y dares permisos de acceso, en el caso de que el dispositivo vaya a a ser utilizado por varios usuarios. De este modo, podrán acceder a unas carpetas y a otras no.

Crear recursos compartidos

Comenzaremos creando una carpeta compartida, para lo que tendremos que seleccionar uno de los Sistemas de archivos de la pantalla correspondiente

Le asignamos los permisos adecuados, pero mi consejo es no ser muy restrictivos al principio.

Después, la añadimos en Servicios -> Samba/CIFS. El servicio lógicamente debe estar  habilitado,  y en caso contrario lo activamos.

Permitiendo invitados. Y finalmente en Permisos de acceso -> Usuario concederemos permisos de lectura y escritura a los usuarios que consideremos.

Cada uno de estos pasos hay que validarlos en la parte superior de la página.

Si todo va bien, en el apartado Red del navegador de archivos nos aparecerá algo parecido a esto:

https://youtu.be/8eY8d1jOUvI

Fuentes:

https://hardzone.es/tutoriales/montaje/raspberry-pi-servidor-nas/

Open Media Vault para Raspberry

Conclusión:

Es posible montar un NAS con una Raspberry, preferentemente de los últimos modelos. Es plenamente operativo, y en mi caso se obtiene una tasa de transferencia sostenida de unos 20-21 mb/s, con archivos grandes eso sí.

Emisora de FM con RDS

Propósito:

Construir una pequeña emisora de frecuencia modulada, que incluso dispone del sistema RDS (Radio Data System).

Material necesario:

Dificultad:

  • Muy fácil

Este proyecto no puede ser más sencillo, ya que prácticamente no requiere más hardware adicional que un cable que actúe como antena, y solo hay que descargar algún software. No obstante, va a servir para utiizar algunas órdenes básica en Linux.

Hay que decir que la emisora tiene muy poca potencia, lógicamente, pero funciona, y que emitir sin licencia es ilegal en muchos países.

Accedemos a la Raspberry mediante SSH con el nombre de usuario pi y la contraseña que eligiéramos en el momento de la instalación. Se abre una consola.

Comenzamos descargando un programa que se denomina PiFmRDS. Para ello tecleamos (o copiamos y pegamos) las siguientes órdenes:

git clone https://github.com/F5OEO/PiFmRds.git

cd PiFmRds/src

git clone https://github.com/F5OEO/librpitx.git

cd librpitx/src

make

cd ../../

make clean

make

Conexiones:

Conectamos el cable al pin GPIO4, que actuará como antena, en este caso en la placa de expansión o directamente en la Raspberry:

Comprobamos que estamos en el directorio /home/pi/PiFmRds y ejecutamos

sudo ./pi_fm_rds

Buscamos una radio FM y sintonizamos la frecuencia de 107.9 MHz. No escucharemos nada, casi, porque hay una señal sin contenido.

Otra cosa es si tecleamos

sudo ./pi_fm_rds -audio sound.wav

En este caso escucharemos alguien hablando. Incluso, si ejecutamos el archivo

sudo ./pi_fm_rds -audio stereo_44100.wav

Comprobaremos que emite en estereo.

La sintaxis completa del programa es

pi_fm_rds [-freq freq] [-audio file] [-ppm ppm_error] [-pi pi_code] [-ps ps_text] [-rt rt_text]

Y así podremos especificar la frecuencia de emisión, el fichero a reproducir, el indicativo de la emisora (ps_text) o el texto que veremos en el RDS (rt_text).

Por ejemplo,

sudo ./pi_fm_rds -freq 107.6 -audio stereo_44100.wav -ps "Hola FM" -rt "Hola cocacola"

emitirá el conocido archivo de audio en la frecuencia de los 107.6 MHz con el indicativo Hola FM.

Genial, pero un poco limitado, porque no podemos reproducir archivos mp3.

Para ello deberemos descargar e instalar las correspondientes liberías y archivos de conversión:

sudo apt-get install ffmpeg sox libsox-fmt-all

Por ejemplo,

sudo sox -t mp3 /home/pi/Music/loquesea/*.mp3 -t wav - |sudo /home/pi/PiFmRds/src/pi_fm_rds -ps 'Hola FM' -rt 'Emitiendo en directo' -audio -

Emitirá todos los mp3 del directorio /loquesea que está dentro de /home/pi/Music

Fuentes:

https://github.com/F5OEO/rpitx/tree/master/src/pifmrds

https://www.instructables.com/Raspberry-Pi-PiFMPlay-Simplified-FM-Transmitter/

Conclusión:

Es posible convertir la Raspberry en una emisora de radio en frecuencias que van desde 1 MHz a 250 MHz, lo que incluye por tanto la banda FM, de 87,5 a los 108,0 MHz. Lo más difícil del proyecto es encontrar una frecuencia libre, si vives en una gran ciudad.