Instalación de FreeNas en una máquina virtual.

En esta entrada vamos a ver como instalar FreeNas.

FreeNAS8.2.0-BETA2

FreeNAS es un sistema operativo basado en FreeBDS que proporciona servicios de almacenamiento en red,  NAS (Network Attached Storage).

Podemos descargar la imagen de FreeNas de la siguiente dirección:

http://www.freenas.org/download/

En nuestro caso vamos a instalar FreeNas en una máquina virtual, que tenemos que preparar de la siguiente manera:

Abrimos VMWare Player y seleccionamos la opción de “Create a New Virtual Machine”

1.png

2

Puesto que tenemos la imagen de FreeNas elegiremos la última opción “I will install the operating system later”

Marcamos la opción other, y seleccionamos FreeBSD 64-bit

3

A continuación indicamos el nombre que queremos dar a la máquina virtual y la ruta donde queremos que se guarde:

4

Dejamos la siguiente ventana con las opciones indicadas por defecto:

5

6

Pulsamos el botón “Customize Hardware” y de memoria Ram aumentamos hasta 512 Mb y en la opción de “CD/DVD IDE” marcamos la opción “Use ISO image file” y le indicamos la ruta donde tenemos guardada la imagen .iso de FreeNas.

Pulsamos “Close” y “Finish”.

7.png

Seleccionamos la máquina virtual que acabamos de crear, y “Play virtual machine”

En la siguiente ventana que aparece, seleccionamos “Download and Install”

8

Una vez que arranca la máquina virtual visualizaremos una imagen como la siguiente:
9

Escogemos la opción 1 “Install/Upgrade” y en la siguiente pantalla con la barra espaciadora seleccionamos nuestra máquina virtual para instalar FreeNas

10

11

Confirmamos, y en la siguiente ventana nos permite asignar una contraseña al usuario “Root”

12

Tras confirmar empieza la instalación

13.png

Una vez termina, si todo ha ido bien, nos saldrá un mensaje como este:

14.png

Reiniciamos la máquina virtual y una vez que termina de arrancar nos aparecerá la siguiente ventana de configuraciones:

15.png

Configuramos una IP estática

16

y nos vamos a cualquier navegador, la introducimos y ya podemos manejar gráficamente nuestro FreeNas.

 

 

Anuncios

Instalación de VMWare y creación de una máquina virtual Ubuntu

Vmware Workstation Player es una herramienta software de virtualización de equipos que proporciona gratuitamente la empresa VMWare, con sede en California.

vmware-player-icon

Podemos descargarla de:

https://my.vmware.com/en/web/vmware/free#desktop_end_user_computing/vmware_workstation_player/12_0

Una vez descargada, la instalamos:

Creación de una Máquina Virtual:

Una vez que tenemos Vmware Workstation Player instalado, necesitamos  descargar Ubuntu, (en nuestro caso la versión 14.04). Cualquier versión que queramos la encontraremos en:
http://releases.ubuntu.com/

Descargamos el archivo .iso:

9.png

Abrimos el VMWare Player y le damos a la opción de “Create a New Virtual Machine”:

10

Puesto que tenemos nuestro archivo .iso, le indicamos que vamos a instalar el sistema operativo después, por tanto marcamos la 3ª opción, “I will install the operating system later”

Y pulsamos el botón de siguiente:

11

A continuación y puesto que en nuestro caso es un sistema operativo Linux, marcamos dicha casilla, y en versión seleccionamos Ubuntu 64-bits y volvemos a pulsar el botón Siguiente:

12

Le damos un nombre a la máquina virtual, y le indicamos la ruta donde queremos guardar nuestra máquina virtual y volvemos a pulsar Siguiente:

13

Ahora le indicamos las características que queramos que posea la máquina virtual en cuanto a tamaño del disco duro y otros. Podemos dejarlo por defecto, puesto que viene recomendado para nuestra maquina según el sistema operativo que le indicamos, o podemos modificarlo a nuestro gusto. Después pulsamos de nuevo el botón de Siguiente y en la última ventana “Finish”.

Y una vez que acaba nos aparecerá lo siguiente:
14

Donde seleccionamos la máquina que acabamos de crear y pulsamos “Edit virtual machine settings”:

15

Nos vamos a CD/DVD (IDE) y ahí en la parte de “Connection” nos vendrá marcada la opción “Use physical drive: “, sin embargo marcamos la de abajo, “Use ISO image file:” puesto que teníamos el fichero .iso con la imagen de nuestro Ubuntu.

16

Le indicamos la ruta donde está la imagen del Ubuntu descargado y le damos a “Ok”

Lo que nos llevará de nuevo a la ventana inicial de VMWare Player, donde volvemos a seleccionar nuestra máquina virtual y está vez le damos a “Play virtual machine”, le damos “Ok” a la ventana emergente que se nos mostrará, y ya tendremos nuestra máquina virtual iniciándose.

Para instalarla seleccionamos el idioma que queramos y le damos a la opción “Install Ubuntu”

17

Después le damos a “Continue”.

En la ventana de Installation type, marcamos la primera opción “Erase disk and install Ubuntu” puesto que es una instalación desde cero, y no queremos añadir ninguna partición a la máquina virtual.

En la siguiente ventana le damos a “Install Now”, a continuación seleccionamos el país, el idioma del teclado, después introducimos nuestros datos, usuario, contraseña en caso de que queramos, y otros datos, y una vez que acabamos de indicar todo y le damos a “Continue” le dejamos que instale la máquina, y una vez que acabe nos saldrá  una ventana como la siguiente:

18.png

Reiniciamos la máquina, y ya la tenemos lista para usar.

Trabajando con OpenCV y la cámara de la Raspberry Pi

Como ya comentábamos en la entrada anterior, podemos hacer reconocimiento de imágenes, en concreto vamos a ver en esta entrada como hacer reconocimiento  de la posición de la mano con OpenCV. Para ello necesitamos conectar y habilitar la cámara de la Raspberry Pi, como indicamos en otra entrada anterior Sistema de vigilancia con Raspberry Pi.

Con el siguiente código podemos hacer que reconozca si la mano está abierta o cerrada:

# import the necessary packages
from imutils.video import VideoStream
import imutils
import cv2
import numpy as np
import math
import time
import sys

# initialize the video stream and allow the cammera sensor to warmup
vs = VideoStream(usePiCamera=True, resolution=(1296,972)).start()
time.sleep(2.0)
# loop over the frames from the video stream
while True:
img = vs.read()
cv2.rectangle(img,(300,300),(100,100),(0,255,0),0)
crop_img = img[100:300, 100:300]
grey = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY)
value = (37,37)
blurred = cv2.GaussianBlur(grey, value, 0)
_, thresh1 = cv2.threshold(blurred, 127, 255,
cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
_, contours, hierarchy = cv2.findContours(thresh1.copy(),cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)

max_area = -1
for i in range(len(contours)):
cnt=contours[i]
area = cv2.contourArea(cnt)
if(area>max_area):
max_area=area
ci=i
cnt=contours[ci]
x,y,w,h = cv2.boundingRect(cnt)
cv2.rectangle(crop_img,(x,y),(x+w,y+h),(0,0,255),0)
hull = cv2.convexHull(cnt)
drawing = np.zeros(crop_img.shape,np.uint8)
cv2.drawContours(drawing,[cnt],0,(0,255,0),0)
cv2.drawContours(drawing,[hull],0,(0,0,255),0)
hull = cv2.convexHull(cnt,returnPoints = False)
defects = cv2.convexityDefects(cnt,hull)
count_defects = 0
cv2.drawContours(thresh1, contours, -1, (0,255,0), 3)
for i in range(defects.shape[0]):
s,e,f,d = defects[i,0]
start = tuple(cnt[s][0])
end = tuple(cnt[e][0])
far = tuple(cnt[f][0])
a = math.sqrt((end[0] – start[0])**2 + (end[1] – start[1])**2)
b = math.sqrt((far[0] – start[0])**2 + (far[1] – start[1])**2)
c = math.sqrt((end[0] – far[0])**2 + (end[1] – far[1])**2)
angle = math.acos((b**2 + c**2 – a**2)/(2*b*c)) * 57
if angle <= 90:
count_defects += 1
cv2.circle(crop_img,far,1,[0,0,255],-1)
dist = cv2.pointPolygonTest(cnt,far,True)
cv2.line(crop_img,start,end,[0,255,0],2)
cv2.circle(crop_img,far,5,[0,0,255],-1)

if count_defects>3:
cv2.putText(img,”ABIERTA”, (50,50), cv2.FONT_HERSHEY_SIMPLEX, 2, 4)
else:
cv2.putText(img,”CERRADA”, (50,50), cv2.FONT_HERSHEY_SIMPLEX, 2, 4)

#cv2.imshow(‘drawing’, drawing)
#cv2.imshow(‘end’, crop_img)
cv2.imshow(‘Gesture’, img)
all_img = np.hstack((drawing, crop_img))
cv2.imshow(‘Contours’, all_img)
k = cv2.waitKey(10)
if k == 27:
cv2.destroyAllWindows()
vs.stop()
break

Lo primero que hacemos es iniciar la cámara de la Raspberry con una resolución concreta, para ir procesando cada imagen que vamos leyendo.

Dibujamos un cuadrado en la posición de la imagen donde estará la mano.

2016-08-19-171040_1824x984_scrot - copia.png

A continuación convertimos la imagen a escala de grises.

2016-08-19-171040_1824x984_scrot-copia-copia

Le aplicamos un filtro Gaussiano, que desenfoca la imágen de la siguiente forma:

bf.png

Después le aplicamos la función treshold, que nos devolvería un resultado similar al siguiente:
hand

Donde podemos localizar, y dibujar muy fácilmente el contorno de la imagen.

2016-08-19-171040_1824x984_scrot - copia (2)

Tras aplicar una serie de funciones matemáticas, podemos interpretar si la mano esta cerrada o abierta.

2016-08-19-171040_1824x984_scrot
Ejemplo Mano Abierta
2016-08-19-171718_1824x984_scrot
Ejemplo Mano Cerrada

Aquí os dejo un vídeo donde os muestra el funcionamiento de esta práctica (tiempo 2:29), además de otras.

 

 

Instalar OpenCV en Raspbian Jessie

OpenCV (Open Source Computer Vision) es una librería software de código abierto sobre visión artificial.

OpenCV_Logo_with_text
Logo OpenCV

Es multiplataforma por lo que existen distintas versiones en C/C++, Java, Python y distintos soportes para cada sistema operativo (Linux, Mac, Windows …).

Contiene más de 500 funciones que abarcan una gran gama de áreas en el proceso de visión, como reconocimiento de objetos o reconocimientos facial, calibración de cámaras, visión estérea y visión robótica.

2016-08-18-171351_1824x984_scrot - copia
Reconocimiento Facial con OpenCV

Siguiendo los pasos que vamos a enumerar a continuación podemos instalar OpenCV en nuestra Raspberry Pi con Raspbian Jessie instalado, en unas dos horas. (25 minutos que tardaremos en preparar todo, y luego algo más de hora y media para dejar que se compile y se instale).

Lo primero de todo será comprobar que la Raspberry está actualizada:

sudo apt-get update

sudo apt-get upgrade

sudo rpi-update

sudo reboot

Una vez actualizada y reiniciada, seguimos con los siguientes pasos, para instalar las dependencias:

sudo apt-get install build-essential git cmake pkg-config

1

sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev

2

sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev

3

sudo apt-get install libxvidcore-dev libx264-dev

4

sudo apt-get install libgtk2.0-dev

5

sudo apt-get install libatlas-base-dev gfortran

6

sudo apt-get install python2.7-dev python3-dev

7

Descargamos y descomprimimos el código fuente de Open CV:

cd ~

8

wget -O opencv.zip https://github.com/Itseez/opencv/archive/3.0.0.zip

9

unzip opencv.zip

10

wget -O opencv_contrib.zip https://github.com/Itseez/opencv_contrib/archive/3.0.0.zip

11

unzip opencv_contrib.zip

12

Configuramos Python, puesto que en nuestro caso será con el que utilizaremos OpenCV en la Raspberry Pi.

wget https://bootstrap.pypa.io/get-pip.py

13

sudo python get-pip.py

14

Virtual Enviroment:

sudo pip install virtualenv virtualenvwrapper

15

sudo rm -rf ~/.cache/pip

16

sudo nano ~/.profile

profile

El archivo debe quedar con el aspecto anterior, guardamos con Ctrl+X  y ejecutamos lo siguiente:

source ~/.profile

18

mkvirtualenv cv

20

Siempre que cerremos sesión o apaguemos la Raspberry, si queremos trabajar en el entorno virtual tenemos que ejecutar lo siguiente:

source ~/.profile

workon cv

Y ya nos aparecerán las letras (cv), indicando que estamos en el entorno virtual

20 - copia

pip install numpy

21

cd ~/opencv-3.0.0/

22

mkdir build

23

cd build

Compilamos e instalamos OpenCV:

24

cmake -D CMAKE_BUILD_TYPE=RELEASE \

-D CMAKE_INSTALL_PREFIX=/usr/local \

-D INSTALL_C_EXAMPLES=ON \

-D INSTALL_PYTHON_EXAMPLES=ON \

-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.0.0/modules \

-D BUILD_EXAMPLES=ON ..

25

Aseguramos que en el apartado de Python 2,  tanto el intérprete , como numpy apuntan al entorno virtual.

26

27

Compilamos:

make -j4

(Si queremos compilar utilizando 4 núcleos)

o make simplemente (compilación más lenta)

28

Empezará la compilación que puede durar hora y media si se usan los 4 núcleos, o más si sólo se utiliza uno.

Si todo sale bien, una vez que llegue al 100 % de la compilación y si no se han recibido mensajes de error, ya tendremos casi listo nuestro Open CV.

29

En caso de recibir error, puedes probar a borrar la compilación con el comando make clean

y una vez eliminada, volver a probar ejecutando make.

Una vez compilado sin errores, seguimos con el siguiente paso:

sudo make install

30

sudo ldconfig

31

cd ~/.virtualenvs/cv/lib/python2.7/site-packages/

32

ln -s /usr/local/lib/python2.7/site-packages/cv2.so cv2.so

33

Y ya tenemos listo nuestro OpenCV en la Raspberry Pi.

Para verificar que todo ha ido correctamente podemos hacer la siguiente comprobación:

python

34

cv2.__version__

35

En entradas posteriores veremos diferentes usos de OpenCV con la cámara de la Raspberry Pi.

Gracias a http://www.pyimagesearch.com/2015/10/26/how-to-install-opencv-3-on-raspbian-jessie/

Sistema de vigilancia con Raspberry Pi

Para seguir con las dos entradas anteriores, y con nuestro proyecto de domótica con Raspberry Pi vamos a explicar como hacer que cuando el sensor PIR detecte movimiento mande una foto capturada por la cámara de la Raspberry Pi al correo de gmail.

admin.schema

Partiendo del programa en python que teníamos para controlar el sensor PIR, vamos a modificar el código de tal forma que cuando se detecte movimiento en vez de escribir por pantalla “movimiento detectado”, ejecute en segundo plano otro programa en python que toma una foto con la cámara oficial de Raspberry Pi.

41vGRDyVq6L._SX425_
Raspberry Pi Camera

Para ello lo primero que tenemos que hacer es conectar la Cámara al CSI de la Raspberry Pi

Raspberry_Pi_CSI_Camera_Module_from_Mobile_Phone
Conexión cámara CSI Raspberry Pi

Y ejecutando en la Raspberry el comando

sudo raspi-config 

Habilitamos la cámara

EnableCamera
Enable Camera comando raspi-config

Instalamos la librería “picamera” con el siguiente comando

 sudo apt-get install python-picamera
Y ya podemos ejecutar el siguiente programa:
#!/usr/bin/env python
import os
from time import sleep
import picamera
import smtplib

ruta = ‘/home/pi/raispi/fotos/pic.jpg’
with picamera.PiCamera() as camera:
camera.start_preview()
#Hacer foto
camera.capture(ruta, format= ‘jpeg’, use_video_port=True)
camera.stop_preview()
camera.close()

#Mandarla como archivo adjunto al correo de gmail
os.system(“./mail.sh &”)

Que a su vez ejecuta en segundo plano lo siguiente:
echo “Imagen por persona detectada” | mutt -s “Movimiento detectado” destinatario@gmail.com -a /home/pi/raispi/fotos/pic.jpg
Dando permiso al programa anterior así como al .sh, con el comando
sudo chmod 777 foto_sensor.py
sudo chmod 777 mail.sh
dejamos la Raspberry Pi un poco oculta cerca de la entrada de casa, y ejecutamos el programa del sensor PIR y cada vez que detecte que alguien entra, tomará una foto y la mandara por correo.
ImagenPersonaDetectada

Enviar un correo desde la Raspberry Pi

Siguiendo con nuestro proyecto de domótica con la Raspberry Pi, en esta entrada vamos a explicar como mandar correos desde la Raspberry Pi que nos puedan servir como aviso de ciertas situaciones que pasan en casa cuando no estamos.

admin.schema

Lo primero que hemos hecho ha sido crear una cuenta de gmail, puesto que necesitábamos otra desde la que mandar los correos.

A continuación instalaremos Mutt, un cliente correo que se puede utilizar desde Terminal.

Para ello ejecutamos desde la Raspberry Pi el siguiente comando:

sudo apt-get install mutt

Después, dentro del directorio /root creamos el  fichero .muttrc y escribimos las siguientes líneas:

File_muttrc
Contenido Fichero /root/muttrc

Donde sustituimos la palabra contraseña por nuestra contraseña real del correo, y guardamos su contenido.

A continuación creamos el siguiente directorio:

mkdir – p /root/.mutt/cache

Ejecutando desde nuestro terminal mutt, ya nos aparecerá nuestra bandeja de entrada y ya podremos enviar y recibir correos.

BandejaCorreo
Bandeja de Correo desde Terminal

Para enviar algún correo sólo tenemos que ejecutar lo siguiente:

echo “Contenido del correo” | mutt –s “Asunto del mensaje” destinatario@gmail.com

CorreoSinAdjuntoFotoCorreoSinAdjuntoCorreoConAdjuntoFtoCorreoConAdjunto

 

Sensor PIR

En este apartado del blog queremos hacer un enfoque más domótico y centrarnos en utilizar la Raspberry Pi con distintos sensores, para ir creando diferentes aspectos de una Smart Home.

admin.schema
Smart Home con Raspberry Pi

En estas primeras entradas de este apartado, vamos a utilizar un sensor PIR y la cámara oficial de la Raspberry Pi para hacer un sistema de vigilancia casero, que sea capaz de hacer fotos cuando detecte que alguien entra en casa, y mandarlas a nuestro correo de Gmail.

Lo primero de todo es explicar que es un sensor PIR de detección de movimiento:

PIR sensor
Sensor Pir HC-SR501

Un sensor PIR (Passive InfraRed) está formado por una lente de Fresnel, un detector de infrarrojos y otros circuitos de detección. La lente en el sensor se centra cualquier radiación infrarroja presente alrededor de ella. Nuestros cuerpos generan calor infrarrojo que es detectado por el sensor, tras lo cual emite una señal de 5 V. Según su hoja de características es capaz de detectar movimiento hasta unos 6-7 metros de distancia.

FuncionamientoPir
Funcionamiento Sensor PIR
EsquematicoSensorPir
Esquemático del sensor PIR HC-SR501

HC-SR501-Image

 

Cuando el sensor de movimiento PIR detecta una persona, se emite una señal de 5 V a la Raspberry Pi a través de su GPIO.

Las conexiones a hacer entre el sensor y la Raspberry Pi se muestran en el siguiente esquema:

ConexionesSensorPir
Conexiones Raspberry Pi y sensor PIR

FotoConexionesSensorPir

El programa a utilizar habiendo conectado la salida del sensor al GPIO 16 de la Raspberry Pi sería uno similar al siguiente:

#!/usr/bin/env python
import RPi.GPIO as GPIO
import time
import os
from time import gmtime, strftime
GPIO.setmode(GPIO.BCM)
PIR_PIN = 16
GPIO.setup(PIR_PIN, GPIO.IN)
time.sleep(5)
try:
while True:
if GPIO.input(PIR_PIN):
print (‘movimiento detectado\n’)
time.sleep(0.3)

except KeyboardInterrupt:
print “quit”
GPIO.cleanup()

Una vez en la carpeta donde hemos creado el fichero anterior, lo ejecutamos:

ResultadoSensorPir
resultado de ejecutar sensor_movimiento.py