Archivo de la etiqueta: Raspberry Pi

Material Curso Smart Cities

Para el curso on-line “Fundamentos IoT y Desarrollo con Node-RED para Smart Cities”, el material necesario por parte de los Asistentes para realizarlo es:

  • 1 PC o Portátil con conexión a internet
  • Para seguir el curso on-line es recomendable dos pantallas, una para seguir el vídeo y otra para programar en Node-RED.

El PC de cada asistente deberá tener un sistema operativo instalado, ya sea un sistema Windows, MacOS o Linux. Las licencias del Sistema Operativo y el software que tenga correrán a cargo del cliente/alumno.

  • Nodo Edge/Gateway. Instalación Node-RED. Recomendable usar Raspberry Pi + tarjeta SD 16Gb + alimentador conectada a Internet por alumno, pero podría usarse una máquina virtual o en un servidor cloud. Opcionalmente puede usarse instancias en la nube de Node-RED desde el servidor de https://www.aprendiendoarduino.com/ 

Las Raspberry Pis se usarán como instancias de Node-RED y nodos edge a los que se conectan los nodos remotos, por lo que no conectaremos sensores/actuadores/periféricos a las Raspberry Pi.

  • Nodos remotos por asistente compuesto por el siguiente material:
    • 2x Wemos D1 min o NodeMCU o equivalente
    • 1x shields para wemos D1 mini relé o equivalente
    • 1x shields para wemos D1 mini neopixel o equivalente
    • 1x shields para wemos D1 mini oled o equivalente
    • 1x shields para wemos D1 mini temperatura (puede ser DHT o
    • de temperatura) o equivalente
    • 1 x Cable USB para programar Wemos

Si el alumno tiene algún HW con que quiera interactuar, puede presentarlo y lo integramos en las prácticas. El HW puede estar tanto en el aula como remotamente en su casa, oficina, etc…

Servicios Cloud para el Curso

Se usará un broker común para comunicar todos los dispositivos: mqtts://aprendiendonodered.com:8883

Los alumnos recibirán usuario y contraseña para acceder al broker con permisos de lectura y escritura en smartcities/#

Base de datos MySQL en https://enriquecrespo.com/phpmyadmin/ donde los alumnos podrán usar para almacenar datos. Los alumnos recibirán las credenciales de acceso.

Base de datos InfluxDB en https://enriquecrespo.com:8086/ donde los alumnos podrán usar para almacenar datos. Los alumnos recibirán las credenciales de acceso.

Grafana en https://enriquecrespo.com:3000/ para representar gráficamente los datos. Recibirán por correo las credenciales de acceso.

Otros servicios programados con Node-RED en aprendiendonodered.com: API, Open Data, servidor FTP, gateway servicios de terceros, simulación de datos, etc… y servicios self hosted (gotify, thingsboard, thinger.io, etc…)

Interacción con servicios cloud de terceros como: APIs, Open Data, Cámaras/Imágenes, Plataformas IoT, Redes Sociales, Servicios de Mensajería, Servicios de alertas, email, etc…

Topología de Prácticas

Programación Básica Python

Introducción a Python

Python es un lenguaje interpretado, es decir, no requiere del proceso de escribir / compilar / volcar. Simplemente escribir la instrucción y listo el ordenador la “interpreta” o sea ejecuta sobre la marcha sin más complicación.

Python también es:

Esto hace que los lenguajes interpretados sean más fáciles de aprender porque nos parecen más naturales, y aunque el programa corre más lento que en los compilados, pero con la potencia actual no es tan importante.

Python es un lenguaje diseñado para ser fácil sin comprometer su potencia. Muy al contrario, la potencia y capacidad de cálculo que muestra suelen sorprender a la gente acostumbrada a otros lenguajes.

Para quienes vengáis de Arduino, C++ es un lenguaje compilado, esto significa que el compilador lee lo escrito en una primera pasada y después compila, es decir traduce a un lenguaje propio del micro de Arduino qué es lo que se vuelca y ejecuta la placa que usemos.

Hay dos versiones de Python 2 y 3, pero la versión 2 ya no tiene soporte desde el 1 de enero de 2020. En Raspberry Pi OS viene instalada la versión 3 de Python.

Para comprobar que tenemos python instalado ejecutar: python –version

Para iniciar python se puede hacer desde consola: python

O usar el entorno gráfico con IDLE. IDLE significa Integrated Development Environment, o Integrated Development and Learning Environment.

Para instalarlo ejecutar: sudo apt-get install idle3

Dentro de la consola ya es posible ejecutar comandos.

Otra opción es usar el Thonny Python IDE incluido en Raspbian: https://thonny.org/

Práctica: Ejecutar los comandos directamente en el terminal de Python

  • 3.8 + 7
  • 2 * (3+5) / 4
  • «Hola»
  • x=3
  • H=»Buenos dias»
  • print(x)
  • print(h)
  • print(H)
  • print(x,H)
  • 123 ** 1234

Python puede con grandes números mientras le quede memoria RAM, pero tu Raspberry puede quedarse un tanto bloqueada mientras calcula.

El resumen es que Python tiene una precisión ilimitadamente grande en los enteros mientras tenga recursos disponibles, un detalle sorprendente para cualquiera que esté acostumbrado a programar en otros lenguajes, y una de las razones por las que Python se ha convertido en lenguaje de facto para la ciencia y especialmente para la investigaciones numéricas.

Más información: Introducción a Python.

Ejecutar un Script de Python en Raspberry Pi

Pasos:

  • Abre el terminal o conecta por SSH
  • nano holamundo.py
  • Escribe en el fichero
#!/usr/bin/python
# -*- encoding: utf-8 -*-
print (“Hola Mundo”)
  • ctrl + o y ctrl + x para guardar y salir
  • Ejecutar con python holamundo.py
  • chmod u+x holamundo.py
  • ./holamundo.py (Hecho el fichero ejecutable)

Práctica: crear un fichero llamado hello.py que saque por pantalla el texto “Hola Mundo” desde consola conectado por ssh y ejecutarlo.

Variables y Tipos de Datos en Python

Una variable es algo parecido a un contenedor o cajón con un nombre. Una cosa es el nombre del cajón y otra su contenido y conviene entender desde ya la diferencia.

Las variables pueden tomar distintos valores e ir cambiandolo en función del programa, de la misma manera que un cajón puede ir variando su contenido sin que se mueva de sitio.

En Python no es necesario definir las variables antes de usarlas, a diferencia de C y similares. Basta con que la declares asignándole un valor.

Por ejemplo escribe directamente:

  • base = 86
  • iva = base * 0.21
  • total = base + iva
  • print (total)
  • print(base, iva, total)
  • base = input («Dame el precio del artículo, por favor : «)
  • print(base + base * 0.21)
  • type(base)
  • print (int(base) + int(base) * 0.21)
  • iva = float(base) * 0.21
  • print (int(base) +iva)

Práctica: Hacer un programa llamado iva.py y que pida el valor del artículo y devuelva el valor con iva.

Más información: Variables y tipos en Python.

En Python existen 4 tipos diferentes de variables numéricas:

  • int Número entero con precisión fija (ℤ).
  • long Número entero en caso de sobrepasar el tamaño de un int.
  • float Número en coma flotante de doble precisión (ℝ).
  • complex Número complejo (parte real + j parte imaginaria) (ℂ)

Una función muy útil, que sirve para conocer el tipo de una variable es: type()

El tipo booleano es un tipo de variable que sólo puede contener dos valores: True y False.

Se definen como caracteres al poner entre comillas simples ‘ o dobles «.

Tipo listas

Se definen poniendo el contenido de la lista entre corchetes, separando cada uno de los elementos mediante una coma. Cada posición de la lista puede contener elementos de distinto tipo. Además, las listas son mutables, es decir, sus elementos pueden ser modificados. En Python los elementos de una lista se numeran desde 0 hasta longitud−1. Hay numerosas funciones que pueden aplicarse a una lista.

Para acceder al elemento de una lista se pone el nombre de la lista y a continuación el índice al que queremos acceder entre corchetes(si ponemos el índice con signo negativo empezará por el final de la lista). Para acceder a un rango dentro de una lista tenemos diferentes opciones:

  • Desde el inicio tomar a elementos (no incluye a):
    lista[:a]
  • Desde la posición a (incluida) tomar todos los elementos hasta el final
    lista[a:]
  • Tomar los elementos desde a hasta b (sin incluir b)
    lista[a:b]

Las listas tienen asociadas una serie de métodos que permiten una gran variedad de operaciones sobre ellas:

  • .append(), añade un elemento al final de la lista.
  • .insert(), se usa para insertar un elemento en el índice asignado.
  • .pop(), elimina y devuelve el valor en la posición del índice asignado.
  • .reverse(), reordena la lista de forma reversa.
  • .sort(), reordena la lista de forma ascendente.

Más en listas: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists

Ejercicio: probar estos ejemplos de listas https://docs.python.org/3/tutorial/datastructures.html#more-on-lists

Tipo tuplas

Las tuplas son similares a las listas, se definen con paréntesis en vez de corchetes. Tienen la peculiaridad de ser inmutables.

Tipo diccionarios

Los diccionarios definen una relación uno a uno entre claves y valores y son mutables. Se definen colocando una lista separada por comas de pares clave:valor. Una vez definido, podemos acceder al valor asociado a una clave buscando por la clave. Además, podemos buscar si una determinada clave existe o no en nuestro diccionario.

Los diccionarios se definen con {}

  • .keys()
  • .values()
  • .items() – devuelve una lista de tuplas clave – valor del diccionario

zip me permite coger dos listas y hacer un diccionario: diccionario = dict(zip(lista_claves,lista_valores))

del(diccionario[‘clave’]) – borra la entrada de un diccionario

Ojo, al copiar un diccionario con ciudades_2 = ciudades, no creo una copia sino dos variables que apuntan a un mismo objeto.

id(diccionario) – me devuelve el número del puntero al diccionario

ciudades_2 = ciudades.copy() -> así tengo una copia independiente de un diccionario

Diccionarios en python: https://devcode.la/tutoriales/diccionarios-en-python/

Ejercicio: ejecutar algunos ejemplos con diccionarios https://recursospython.com/guias-y-manuales/diccionarios/

Ver:

Operadores aritméticos

Las diferentes operaciones aritméticas en Python son los siguientes:

  • +
  • ∗∗  – elevado
  • / – división entera
  • // – división
  • %

Operadores de asignación

Los diferentes operadores de asignación en Python son los siguientes:

  • =: Asigna a la variable del lado derecho aquello que pongamos en el lado derecho.
  • +=: Suma a la variable del lado izquierdo la variable del lado derecho.
  • −=: Resta a la variable del lado izquierdo la variable del lado derecho.
  • ∗=: Multiplica la variable del lado izquierdo por la variable del lado derecho.
  • /=: Divide la variable del lado izquierdo por la variable del lado derecho.
  • ∗∗=: Eleva la variable de la izquierda a la potencia de la variable de la derecha.
  • //=: División entera de la variable de la izquierda entre la de la derecha.
  • %=: Resto de la división de la variable de la izquierda entre la de la derecha.

Operadores relacionales

Los operadores relacionales de Python son:

  • ==: Evalúa que los valores sean iguales.
  • !=: Evalúa que los valores sean distintos.
  • <: Evalúa que el valor de la izquierda sea menor que el de la derecha.
  • >: Evalúa que el valor de la izquierda sea mayor que el de la derecha.
  • <=: Evalúa que el valor de la izquierda sea menor o igual que el de la derecha.
  • >=: Evalúa que el valor de la izquierda sea mayor o igual que el de la derecha.
  • not: negación de una variable booleana

Librerías

Python es un lenguaje pensado para ser ampliado con lo necesario y hace tiempo que se ha convertido en el pilar de la investigación en numerosos campos de ciencia y tecnología

pip es el gestor de paquetes más usado en python: https://pypi.org/project/pip/ 

La forma más sencilla de instalar una librería es pip install <module_name>

Disponemos de infinidad de librerías que podemos usar llamando a la clausula import <module_name>

La librería estándar de python incluye muchos módulos: https://docs.python.org/dev/library/index.html

Ejecutar:

  • from fractions import *
  • F1 = Fraction(2,3)
  • F2 = Fraction(3,4
  • print(F1, F2)
  • print (F1 + F2)
  • print (F1 * F2)
  • print (F1 / F2)
  • import math
  • math.factorial(4)
  • math.factorial(432)
  • import numpy
  • a = numpy.array(([1,2,3],[4,5,6],[7,8,9]))
  • print (a)
  • print (a * a)
  • from matplotlib import pyplot
  • pip install matplot lib
  • x = numpy.linspace(0, 2 * numpy.pi, 100)
  • y = numpy.sin(x)
  • pyplot.plot(x, y)
  • pyplot.show()

NumPy es una extensión de Python, que le agrega mayor soporte para vectores y matrices, constituyendo una biblioteca de funciones matemáticas de alto nivel para operar con esos vectores o matrices.

Estos módulos externos que podemos descargar e importar a nuestros programas reciben en Python el nombre de packages. Existen packages que podemos importar, más o menos estándar para lo que se te ocurra.

Python Package Index: https://pypi.org/

Más información: Imports en Python

Módulos en Python: http://research.iac.es/sieinvens/python-course/source/modulos.html

Módulos y paquetes: https://www.learnpython.org/en/Modules_and_Packages 

Diferencia entre módulos, Paquetes y librerías

Standar Library: https://docs.python.org/3/library/ 

Métodos de instalación de Paquetes:

Como instalar y usar pip: https://pip.pypa.io/en/latest/installing.html

Por defecto estos gestores de paquetes buscan en https://pypi.org/

El Python Package Index o PyPI es el repositorio de software oficial para aplicaciones de terceros en el lenguaje de programación Python. Los desarrolladores de Python pretenden que sea un catálogo exhaustivo de todos los paquetes de Python escritos en código abierto. https://es.wikipedia.org/wiki/%C3%8Dndice_de_paquetes_de_Python

Para ver la ruta de los paquetes:

  • import sys
  • print (‘\n’.join(sys.path))

Para ver los módulos instalados: pip freeze o pip list

Para actualizar ejecutar: pip install –upgrade pip

Instalar paquetes de Python: https://www.raspberrypi.org/documentation/linux/software/python.md

Sentencias condicionales

Imaginemos que queremos crear un sistema automático de riego en nuestra casa, de forma que cuando la lectura de un sensor de humedad sea menor que un cierto valor, encienda el sistema y que si la lectura es mayor que un cierto valor, lo apague. Con las herramientas que tenemos hasta ahora, esto no sería posible, para esto utilizamos la sentencia if/elif/else, que tiene la siguiente estructura:

if <expresion_booleana>:   # Solo si la condicion booleana es True, 
    bloque codigo          # el bloque de código se ejecuta
    ...
elif <expresion_booleana>: # No es necesario, añade condiciones extra al conjunto.
    bloque codigo          # Se puede poner tantas como se necesiten.
    ...
else:                      # No se necesario. Se ejecuta solo si
    bloque codigo          # todas las condiciones anteriores son falsas.         
    ...

Nota: Es importante saber la importancia de la indentación en Python. Cuando usemos sentencias que acaben en «:» (if, for…) las líneas que estén dentro de esta sentencia irán después de un tabulador o 4 espacios, como se muestra en los ejemplos.

Ejemplo:

num = float(input("Enter a number: "))
if num >= 0:
    if num == 0:
        print("Zero")
    else:
        print("Positive number")
else:
    print("Negative number")

Más información: El tipo Bool y sus operaciones.

Sentencias bucle

Anteriormente hemos visto el tipo de variable lista. Estas contenían una cierta cantidad de elementos. Imaginemos que tenemos una lista de enteros y queremos mostrar por pantalla los elementos que contiene que sean mayores que 5. Para esto, entre otras cosas, tenemos sentencias bucle.

En Python existen dos tipos estructuras de bucles:

  • Bucles for
  • Bucles while

La sintaxis de un bucle for es:

for <variable_sin_definir> in <Iterable>: # El bloque se ejecuta tantas veces 
    bloque codigo                         # como elementos tiene el iterable
    ...

El bucle ejecuta un bloque de código tantas veces como esté definido. El número de veces que se recorre el bucle es equivalente al número de elementos en el iterable que se usa. La variable que se usa toma como valores los elementos del iterable de forma secuencial, un valor por cada iteración.

Los bucles for son una gran herramienta para recorrer todos los elementos de una colección.

Ejemplo:

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

Ejemplo:

for x in range(6):
  print(x)
else:
  print("Finally finished!")

La sintaxis de los bucles while es:

while <condicion_boolena>:   # El bloque se ejecuta hasta que la condición es falsa.
    bloque codigo            # Antes de ejecutar asegurarse que se va a salir.
    ...

El bucle while se ejecuta de forma indefinida hasta que la condición después del while sea falsa. Por lo tanto es necesario realizar un cambio dentro del bucle que finalmente hará que se vuelva la condición False.

Adicionalmente existen un par de comandos dentro de Python que sirven para tener más control sobre los bucles:

  • continue. El intérprete cuando lo lee termina de ejecutar la presente iteración y pasa a la siguiente iteración.
  • break . El intérprete cuando lo lee termina la ejecución del bucle, continuando la ejecución de las siguientes líneas.

Ejemplo:

i = 1
while i < 6:
  print(i)
  if i == 3:
    break
  i += 1

Más información: Mas sobre Python for y While.

Iteradores

En Python existen diferentes estructuras que son conjuntos de elementos, son las llamadas colecciones. Este tipo de estructuras son iterables, es decir, se pueden recorrer elemento por elemento. Como veíamos antes, el bucle for itera sobre un iterable, por lo que utilizamos esta sentencia para recorrerlos. Algunos tipos de variable que son iterables son:

  • Cadena de caracteres (str)
  • Lista (list)
  • Tupla (tuple)
  • Diccionario (dict)

Además, muchas veces queremos repetir un bucle un número determinado de veces. Para esto puede ser útil la función range(n). Esta función genera un iterable que va desde 0 hasta n-1.

Más información:Iteraciones for en Python 3.

Funciones

Es muy posible que a lo largo de un programa necesitemos calcular el factorial de un número. Podemos escribir el código necesario para calcularlo en cada punto que lo necesitamos, o crear una función que podamos llamar desde cualquier punto y nos calcule el factorial de un número. 

La sintaxis para definir una función en Python es la siguiente:

def nombre_funcion(<parametro1>, <parametro2>, ...): # Los parametros son opcionales
    Bloque codigo
    ...
    return <valor_a_devolver> # El comando es opcional (puede devolver varios valores)

Los parámetros son las variables que se definen dentro del paréntesis, separados por comas. Son opcionales y sirven para pasarle valores a la función. Son opcionales una vez definimos la función, pero si la función está definida con n argumentos, tendremos que informarlos.

Adicionalmente puede introducirse una sentencia return que termina la ejecución de la función y devuelve el valor/objeto que está colocado justo después.

Los nombres de las funciones sigue el mismo convenio que el de las variables.

Para llamar a una función, como hemos visto antes, tenemos que escribir el nombre de la función y añadir entre paréntesis los argumentos que la funció necesita. Aunque la función no necesite argumentos, tenemos que escribir los paréntesis.

Ejemplo:

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

Código de python (ejemplos y snippets):

Ayuda de Paquetes y Módulos

Se usa la instrucción help() para obtener los documentos sobre todas las funciones a la vez:

  • import requests
  • help(requests)
  • help(requests.api)

Para simplemente enumerar los nombres de todas las funciones y variables definidas en el módulo: dir(module)

Ejemplos de Python aplicados a la Industria

Ejemplos:

Ejercicio: Recoger datos meteorológicos de aemet

Aemet Open data: http://www.aemet.es/es/datos_abiertos/AEMET_OpenData

Obtener Api Key, necesario un email: https://opendata.aemet.es/centrodedescargas/inicio

Documentación de la API: https://opendata.aemet.es/dist/index.html?

Ejemplo programa Python: https://opendata.aemet.es/centrodedescargas/ejemProgramas?

Crear un ejemplo usando la librería requests: https://pypi.org/project/requests/ y ejecutar para obtener datos de La Rioja.

Instalar librería requests: pip install requests

Crear un nuevo fichero llamado aemet.py en la carpeta /home/pi/ejercicios: nano aemet1.py

Copiar el código del ejercicio poniendo la API key de la AEMET: https://github.com/jecrespo/Aprendiendo-RaspberryPi/blob/master/Ejercicio03-Aemet/aemet.py

Ejecutar con python aemet1.py:

  • Listado de las estaciones de aemet
  • Listado de estaciones en La Rioja
  • Datos históricos diarios de la estación de La Rioja de los últimos 7 días

Librería python-aemet que nos facilita el trabajo: https://pypi.org/project/python-aemet/

No hay librería de AEMET en Node-RED, pero podemos hacer las peticiones a la web como se ha hecho en Python.

Instalar: pip install python-aemet

Crear el fichero aemet2.py: nano aemet2.py

Copiar el código:

from aemet import Aemet

aemet = Aemet('apy key')
observaciones = aemet.get_observacion_convencional('9170')  # Logroño
assert type(observaciones) is list

for observacion in observaciones:
    print(observacion.__dict__)

Ejecutar con: python aemet2.py

  • Obtener las últimas observaciones de la estación meteorológica de La Rioja

Todos los métodos disponibles: 

Paso a Paso: Instalación Servicios Raspberry Pi

Webmin

Webmin es una herramienta de configuración de sistemas accesible vía web para sistemas Unix, como GNU/Linux y OpenSolaris. Con él se pueden configurar aspectos internos de muchos sistemas operativos, como usuarios, cuotas de espacio, servicios, archivos de configuración, apagado del equipo, etcétera, así como modificar y controlar muchas aplicaciones libres, como el servidor web Apache, PHP, MySQL, DNS, Samba, DHCP, entre otros.

Instalar con apt desde el repositorio de webmin. Comandos: 

sudo sh -c 'echo "deb http://download.webmin.com/download/repository sarge contrib" > /etc/apt/sources.list.d/webmin.list'

cd /home/pi
wget https://download.webmin.com/jcameron-key.asc
sudo cat jcameron-key.asc | gpg --dearmor >jcameron-key.gpg
sudo cp jcameron-key.gpg /etc/apt/trusted.gpg.d
rm jcameron-key.*
sudo apt-get install apt-transport-https
sudo apt update
sudo apt install webmin
sudo /etc/webmin/start
sudo systemctl enable webmin 

Para comprobar que se ha instalado acceder desde un navegador a https://ip_address:10000

Navegar por las opciones de webmin y hacer:

  • Ver recursos usados
  • Ver procesos ejecutándose
  • Ver los cron jobs configurados
  • Ver los logs
  • Ver los usuarios y grupos
  • Ver los servidores instalados
  • Ver la configuración de red

Node-RED

Ejecutar el comando para instalar y actualizar: bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)

Pulsar “y” a las preguntas en la instalación.

Para ejecutar Node-RED en el arranque: sudo systemctl enable nodered.service

Para iniciar el servicio: sudo systemctl start nodered.service

En caso de problemas ver el log con: node-red-log

Una vez instalado entrar en http://ip_address:1880

Navegar por Node-RED y poner el nodo inject y debug, unirlos y hacer deploy. Visualizar la pestaña de debug al pulsar sobre el nodo inject.

Añadir un nodo función y poner este código javascript:

// Create a Date object from the payload
var date = new Date(msg.payload);
// Change the payload to be a formatted Date string
msg.payload = date.toString();
// Return the message so it can be sent on
return msg;

Ahora se ve la fecha en un formato legible para humanos.

Instalar la librería moment https://flows.nodered.org/node/node-red-contrib-moment desde el gestor de paletas y sustituir el nodo función por un nodo moment.

First flow: https://nodered.org/docs/tutorials/first-flow 

SQLite

Instalar SQLite:

  • sudo apt update
  • sudo apt install sqlite3

Instalar SQLite Browser:

  • sudo apt update
  • sudo apt install sqlitebrowser

Usaremos SQLite como BBDD local y luego pasar datos a una BBD cloud. Así disponemos de un sistema de almacenamiento local en lugar de una BBDD más compleja o un fichero en local en un formato como json, que es más simple y menos funcional.

Crear una nueva base de datos desde sqlitebrowser llamada datosxx.db en /home/pi/BBDD, siendo xx el número de las Raspberry Pi asignada.

Mediante comandos ejecutar:

  • cd /home/pi
  • mkdir BBDD
  • cd BBDD
  • sqlite3 datosxx.db
$sqlite3 datos15.db
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Crear una tabla llamada datos_aleatorios con tres campos, tal y como muestra la imagen:

  • id (Clave primaria, autoincremento, único)
  • fecha (tipo texto)
  • dato (tipo texto)

Desde la hoja de datos probar a insertar algunos datos

Mediante comandos ejecutar desde la consola de SQLite:

CREATE TABLE "datos_aleatorios" ( "id" INTEGER UNIQUE, "fecha" TEXT, "dato" TEXT, PRIMARY KEY("id" AUTOINCREMENT) );

Comandos SQLite

  • .help – ayuda
  • .database – listas nombres y ficheros de las bases de datos
  • .exit – salir
  • .tables – muestra las tablas
  • CLI sqlite: https://www.sqlite.org/cli.html

Si queremos usar un interfaz web sencillo para visualizar y hacer operaciones sencillas usar: https://github.com/coleifer/sqlite-web 

Para instalar ejecutar los comandos:

  • sudo pip install sqlite-web
  • sqlite_web –host 0.0.0.0 prueba.db 

Insertar Datos Aleatorios desde Node-RED

Conectarse a Node-RED: http://ip_address:1880

Copiar este texto y pegar en Node-RED en Menú – Import – Clipboard

[{"id":"35d3814e6567ee71","type":"tab","label":"Flow 1","disabled":false,"info":"","env":[]},{"id":"cf5e958c1024f743","type":"sqlite","z":"35d3814e6567ee71","mydb":"2542c44b886edf9f","sqlquery":"msg.topic","sql":"","name":"","x":600,"y":100,"wires":[["1be92c5ab1762656"]]},{"id":"e760762917e72c6d","type":"inject","z":"35d3814e6567ee71","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"15","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":190,"y":100,"wires":[["09e0bc6424dbe364"]]},{"id":"09e0bc6424dbe364","type":"change","z":"35d3814e6567ee71","name":"","rules":[{"t":"set","p":"topic","pt":"msg","to":"\"INSERT INTO datos_aleatorios ('fecha','dato') VALUES ('\"&$now('[M01]/[D01]/[Y0001] [H01]:[m01]:[s01]','+0200')&\"','\"&$random()&\"')\"","tot":"jsonata"}],"action":"","property":"","from":"","to":"","reg":false,"x":360,"y":100,"wires":[["cf5e958c1024f743"]]},{"id":"1be92c5ab1762656","type":"debug","z":"35d3814e6567ee71","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","statusVal":"","statusType":"auto","x":590,"y":200,"wires":[]},{"id":"2542c44b886edf9f","type":"sqlitedb","db":"/home/pi/BBDD/datos15.db","mode":"RWC"}]

Y pulsar en Deploy para cargar el flujo.

Resolver los errores, revisar los nodos del flujo creado.

  • Instalar la librería node-red-node-sqlite desde el menú Manage palette
  • Poner la ruta al fichero que contiene la base de datos

Este flujo inserta cada 15 segundos un dato aleatorio en la tabla de la base de datos creada.

Comprobar que graba los datos aleatorios en la BBDD recién creada.

Instalación Software Raspberry Pi

Instalar Servidor LAMP

El acrónimo LAMP está compuesto por las iniciales de sus cuatro componentes: Linux, Apache, MySQL y PHP. Estos forman la infraestructura en el servidor, que hace posible la creación y el alojamiento de páginas web dinámicas. Los componentes individuales se acumulan unos sobre otros, por lo que esta plataforma también recibe el nombre de LAMP stack (del inglés “apilar”).

Su funcionamiento es muy simple. Linux sirve como sistema operativo base para ejecutar el servidor web Apache. Este último no puede interpretar contenidos dinámicos, pero es aquí donde PHP entra a ejercer sus funciones de programación del lado del servidor. El proceso funciona entonces de la siguiente manera: Apache le envía un código fuente al intérprete PHP, incluyendo la información correspondiente sobre las acciones del visitante de la web, y permite el acceso a la base de datos MySQL. El resultado es devuelto a Apache y este se muestra finalmente en el navegador web del visitante.

El lenguaje de programación PHP es uno de los más extendidos para el desarrollo de páginas web. La ventaja de utilizar PHP para el desarrollo de páginas web es que nos permite crear páginas web dinámicas, es decir, que se generan cuando un usuario visita la página.

MySQL es un sistema de gestión de bases de datos relacional desarrollado bajo licencia dual: Licencia pública general/Licencia comercial por Oracle Corporation y está considerada como la base datos de código abierto más popular del mundo, y una de las más populares en general junto a Oracle y Microsoft SQL Server, sobre todo para entornos de desarrollo web.

La alternativa libre es mariaDB: https://mariadb.org/ 

Este proyecto monta un pequeño servidor web Apache con lo que podrías por ejemplo alojar tu propia página web entre otras cosas. Además, si despliegas alrededor de tu casa, por ejemplo, varios sensores y actuadores (temperatura, humedad, luces, etc…) comandados por Arduino, podrías utilizar la Raspberry Pi 3como centro de envío y recepción de datos a través de su red. Y por supuesto utilizar la página Web para mostrar y controlar los datos a través de Internet.

Instrucciones para su instalación:

#Update system

  • sudo apt-get update
  • sudo apt-get upgrade

#Install Apache2

  • sudo apt-get install apache2

Comprobar que accedemos entrando a la IP de la Raspberry Pi desde un navegador

La página web por defecto está en /var/www/html

Crear un fichero prueba.html en el directorio /var/www/html que contenga el texto: “HOLA MUNDO”

Para comprobar que funciona entrar desde un navegador a la dirección: http://ip_raspberry/prueba.html y ver que aparece el texto “HOLA MUNDO”

También podemos comprobar que funciona conectando un Arduino a la red de la Raspberry Pi y cargar este sketch: https://github.com/jecrespo/Curso-IoT-Open-Source/blob/master/Conecta_Raspberry/Conecta_Raspberry.ino 

Curso configuración Apache: https://plataforma.josedomingo.org/pledin/cursos/apache24/ 

#Install PHP

  • sudo apt-get install php libapache2-mod-php

La versión que se instala es la 7.

Para comprobar el funcionamiento crear un fichero llamado info.php y en su interior el código: <?php phpinfo(); ?>

Luego en un navegador ir a http://IP-raspberry/info.php

#Install MariaDB

  • sudo apt-get install mariadb-server mariadb-client php-mysql
  • sudo mysql_secure_installation
  • sudo service apache2 restart

#Install MySQL (ya no está en los repositorios oficiales)

En caso de querer instalar MySQL usar estos comandos:

Más información:

Durante el proceso de instalación se pedirá el password de root de MySQL, poner el mismo que tiene el usuario pi de la Raspberry Pi y poner a Yes todas las opciones de mysql_secure_installation

Para comprobar que todo funciona ejecutar sudo mysql -u root -p y poner la contraseña, saldrá:

Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 61
Server version: 10.1.23-MariaDB-9+deb9u1 Raspbian 9.0

Copyright (c) 2000, 2017, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

Para conectarnos remotamente a MySQL podemos usar:

#Install PhpMyAdmin

  • sudo apt-get install phpmyadmin

Durante el proceso pide la contraseña del usuario phpmyadmin de MySQL y el servidor a instalar el apache y poner yes en dbconfig-common

En caso que no hayamos configurado el servidor web correctamente o queramos hacer una configuración de phpmyadmin después de la instalación, usar el comando: sudo dpkg-reconfigure -plow phpmyadmin

phpMyAdmin es una herramienta escrita en PHP con la intención de manejar la administración de MySQL a través de páginas web, utilizando Internet. Actualmente puede crear y eliminar Bases de Datos, crear, eliminar y alterar tablas, borrar, editar y añadir campos, ejecutar cualquier sentencia SQL, administrar claves en campos, administrar privilegios, exportar datos en varios formatos y está disponible en 72 idiomas. Se encuentra disponible bajo la licencia GPL Versión 2.

Para probar que funciona ver en un navegador: http://IP-raspberry/phpmyadmin con el usuario phpmyadmin y la contraseña usada.

El usuario phpmyadmin no tiene privilegios. Para crear un usuario “pi” con privilegios ejecutar:

  • sudo mysql -u root -p
  • CREATE USER ‘pi’@’localhost’ IDENTIFIED BY ‘tu_contrasena‘;
  • CREATE USER ‘pi’@’%’ IDENTIFIED BY ‘tu_contrasena‘;
  • GRANT ALL PRIVILEGES ON * . * TO ‘pi’@’localhost’; (Para acceso local)
  • GRANT ALL PRIVILEGES ON *.* TO ‘pi’@’%’;  (Para acceso remoto)
  • GRANT GRANT OPTION ON *.* TO ‘pi’@’localhost’; (Privilegios para dar permisos a otros usuarios)
  • FLUSH PRIVILEGES;

Para conectarnos desde otro servidor: mysql -h ip_raspberry -u root -p

#Install servidor ftp (VSFTPD)

  • sudo apt-get install vsftpd

Una vez instalado, configurar con: sudo nano /etc/vsftpd.conf 

Comentar estas dos opciones:

#local_enable=YES
#ssl_enable=NO

Y añadir al final del fichero:

# CUSTOM
ssl_enable=YES
local_enable=YES
chroot_local_user=YES
local_root=/var/www
user_sub_token=pi
write_enable=YES
local_umask=002
allow_writeable_chroot=YES
ftpd_banner=Welcome to my Raspberry Pi FTP service.

También necesitamos añadir el usuario pi al grupo www-data, dar la propiedad de la carpeta /var/www al usuario y al grupo www-data, cambiar la carpeta de inicio del usuario pi a la misma, y aflojar algunos permisos en la carpeta /var/www:

  • sudo usermod -a -G www-data pi
  • sudo usermod -m -d /var/www pi
  • sudo chown -R www-data:www-data /var/www
  • sudo chmod -R 775 /var/www

Y reiniciar el servicio: sudo service vsftpd restart 

Para comprobar que funciona usar un cliente ftp con https://filezilla-project.org/ y hacer una conexión con la siguiente configuración:

  • Host – 192.xxx.x.xxx (IP address)
  • Port – 21
  • Protocol – FTP (File Transfer Protocol)
  • Encryption – Use explicit FTP over TLS if available
  • Logon Type – Normal (username & password)
  • Username – pi
  • Password – [enter password]

Más información: 

Y si quisieramos instalar un wordpress: https://www.raspberrypi.org/learning/lamp-web-server-with-wordpress/

Con esto ya tenemos listo un servidor para recibir conexiones de arduino y guardar datos y mostrarlos.

Recordar cada vez que se haga una modificación grande en Raspberry Pi hacer una copia de seguridad de la tarjeta SD con Win32DiskImager.

Descarga https://sourceforge.net/projects/win32diskimager/

Escribir el nombre de la imagen en la ruta donde los guardemos.

Y luego pulsar read. Una vez hecho esto, esperar a que el proceso finalice.

Instalar Webmin

Webmin es una herramienta de configuración de sistemas accesible vía web para sistemas Unix, como GNU/Linux y OpenSolaris. Con él se pueden configurar aspectos internos de muchos sistemas operativos, como usuarios, cuotas de espacio, servicios, archivos de configuración, apagado del equipo, etcétera, así como modificar y controlar muchas aplicaciones libres, como el servidor web Apache, PHP, MySQL, DNS, Samba, DHCP, entre otros.

Web: http://www.webmin.com/

Instalar Webmin en debian: https://www.webmin.com/deb.html 

Instalar con apt desde el repositorio de webmin. Comandos: 

Instalación Manual:

Es posible que haya que instalar algunas dependencias con:

  • sudo apt-get install perl libnet-ssleay-perl openssl libauthen-pam-perl libpam-runtime libio-pty-perl apt-show-versions python

Para comprobar que se ha instalado acceder desde un navegador a https://ip_address:10000

Más información:

Instalar Node-RED

No instalar la versión que aparece en el software recomendado de Raspberry Pi OS, ni usar apt

Seguir esta instalacióm: https://nodered.org/docs/getting-started/raspberrypi 

Ejecutar el comando para instalar y actualizar: bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)

Para ejecutar Node-RED en el arranque: sudo systemctl enable nodered.service

Para iniciar el servicio: sudo systemctl start nodered.service

En caso de problemas ver el log con: node-red-log

Instalar SQLite

SQLite es una herramienta de software libre, que permite almacenar información en dispositivos empotrados de una forma sencilla, eficaz, potente, rápida y en equipos con pocas capacidades de hardware.

Web: https://sqlite.org/index.html 

Más información:

Documentación: https://sqlite.org/docs.html 

CLI: https://sqlite.org/cli.html 

Integración con json: https://sqlite.org/json1.html 

Porqué usar SQLite:

  • Una base de datos SQLite completa se almacena en un único archivo de disco multiplataforma
  • SQLite es muy pequeño y ligero
  • SQLite es autónomo (no se requieren dependencias externas)
  • SQLite no requiere un proceso o sistema de servidor separado para operar (sin servidor)
  • SQLite viene con configuración cero (no se necesita configuración)
  • SQLite es multiplataforma. Está disponible en UNIX (Linux, Mac OS-X, Android, iOS) y Windows (Win32, WinCE, WinRT)

Instalar SQLite: sudo apt-get install sqlite3

Tutoriales instalación:

DB Browser for SQLite (DB4S) es una herramienta de código abierto, visual y de alta calidad para crear, diseñar y editar archivos de bases de datos compatibles con SQLite.

Web http://sqlitebrowser.org/

Instalar SQLite Browser:

  • sudo apt-get update
  • sudo apt-get install sqlitebrowser

Usaremos SQLite como BBDD local y luego pasar datos a una BBD cloud. Así disponemos de un sistema de almacenamiento local en lugar de una BBDD más compleja o un fichero en local en un formato como json, que es más simple y menos funcional.

Si queremos usar un interfaz web sencillo para visualizar y hacer operaciones sencillas usar: https://github.com/coleifer/sqlite-web 

Para instalar ejecutar los comandos:

  • sudo pip install sqlite-web
  • sqlite_web –host 0.0.0.0 prueba.db

Conceptos Básicos de Linux

Raspberry Pi OS es el sistema operativo oficial para Raspberry Pi basado en Debian.

Usar Linux en Raspberry Pi: https://www.raspberrypi.com/documentation/computers/using_linux.html

El Kernel de Linux: https://www.raspberrypi.com/documentation/computers/linux_kernel.html

Qué es Linux

GNU/Linux es un conjunto de sistemas operativos libres multiplataforma, multiusuario y multitarea basados en Unix. El sistema es la combinación de varios proyectos, entre los cuales destacan GNU, encabezado por Richard Stallman y la Free Software Foundation junto con el núcleo o kernel «Linux», programado por Linus Torvalds.

Linux es un sistema operativo que puede incluir desde pequeños dispositivos embebidos como open-wrt hasta grandes clusters de servidores.

Introducción a Linux: http://www.tldp.org/LDP/intro-linux/html/index.html

Fundamentos de Linux: https://www.raspberrypi.com/documentation/computers/using_linux.html 

Distribuciones Linux: https://es.wikipedia.org/wiki/Distribuci%C3%B3n_Linux

Raspberry Pi OS

Raspberry Pi OS es una distribución del sistema operativo GNU/Linux basado en Debian, y por lo tanto libre para la SBC Raspberry Pi, orientado a la enseñanza de informática. El lanzamiento inicial fue en junio de 2012. Desde 2015, la Raspberry Pi Foundation lo ha proporcionado de forma oficial como el sistema operativo primario para la familia de placas SBC de Raspberry Pi. Hay varias versiones de Raspbian, siendo la actual Raspbian Bullseye.

Raspberry Pi OS: https://www.raspberrypi.com/documentation/computers/os.html 

Configuración: https://www.raspberrypi.com/documentation/computers/configuration.html 

Acceso Remoto: https://www.raspberrypi.com/documentation/computers/remote-access.html 

Fundamentos de Linux: https://www.raspberrypi.com/documentation/computers/using_linux.html 

Terminal. CLI (Command Line Interface)

Lo primero es familiarizarse con la línea de comandos (también conocido como «terminal»). 

Para acceder podemos usar el emulador de terminal que hay en el escritorio de Raspberry Pi OS o usar un cliente para conectarnos por SSH como PuTTY.

Herramienta interesante alternativa a Putty: https://mremoteng.org/download

Probar lo siguiente en la línea de comandos o terminal:

  • Navegar por directorios con comandos como ls, cd y pwd
  • Crea, elimina y cambia el nombre de los directorios con los comandos mkdir, rm , mv y cp
  • Crea un archivo de texto con un editor de línea de comandos como Vi, Vim, Emacs o Nano.
  • Prueba otros comandos útiles como:  chmod , chown , w , cat , more , less , tail , free , df , ps , uname y kill
  • Para saber las opciones de los comandos usar <comando> –help o man <comando>

Absolutamente Básico: http://www.tldp.org/LDP/intro-linux/html/sect_02_02.html

Ayuda: http://www.tldp.org/LDP/intro-linux/html/sect_02_03.html

La mejor manera de obtener ayuda con un comando es leer su «página de uso» (abreviatura de manual); escribe man <comando> en la línea de comando para acceder a la descripción detallada del comando.

La línea de comando https://www.luisllamas.es/consola-de-comandos-raspberry-pi/ 

Práctica: ejecutar los comandos y crear un nuevo fichero info.txt que contenga un texto corto y leerlo.

Comandos Útiles

Es importante conocer y practicar con los comandos para trabajar con Raspberry Pi.

Comandos básicos: https://www.raspberrypi.com/documentation/computers/using_linux.html#other-useful-commands 

Comandos útiles:

  • apt-get update: Actualiza tu versión de Raspbian.
  • apt-get upgrade: Actualiza todos los paquetes que tienes instalados en el sistema.
  • rm: borra fichero
  • cat: visualiza un fichero de texto
  • clear: limpia la ventana del terminal.
  • date: Muestra la fecha actual.
  • find / -name prueba.txt: Busca en todo el sistema el archivo prueba.txt y genera una lista de todos los directorios que contienen el archivo.
  • nano prueba.txt: Abre el archivo prueba.txt en “Nano”, el editor de texto de Linux.
  • poweroff: Apaga el sistema de forma inmediata.
  • raspi-config: Abre el menú de configuración.
  • reboot: Reinicia el sistema de forma inmediata.
  • shutdown -h now: Apaga el sistema de forma inmediata.
  • shutdown -h 18:34: Apaga el sistema a las 18:34.
  • startx: Abre el interfaz gráfico de usuario.
  • ps: mostrar procesos
  • pstree: mostrar árbol de procesos del sistema
  • kill -9 PID: matar proceso por PID obtenido con ps
  • top o htop: mostrar tareas y recurso
  • free -h: ver consumo de memoria
  • df -h: espacio libre en disco
  • tail /var/log/messages: mostrar últimos eventos del sistema

Usar apt: https://www.luisllamas.es/raspberry-pi-instalar-actualizar-programas-apt/

Apagado correcto de Raspberry Pi: https://www.luisllamas.es/como-apagar-o-reiniciar-correctamente-raspberry-pi/

Práctica: descargar el fichero https://raw.githubusercontent.com/aprendiendonodered/DEMO-WEBAPP-DASHBOARD/master/package.json y hacer varias manipulaciones.

Buena web con comandos de todo tipo: https://ss64.com/ 

Buen listado de comandos útiles de Linux: https://www.luisllamas.es/listado-comandos-linux-utiles/ 

Editores de Texto

Editores de texto en terminal:

  • nano
  • vi
  • emacs

Editores de texto:

Manual de uso de nano: https://www.luisllamas.es/raspberry-pi-nano/

Usuarios y Grupos

El sistema operativo Linux es un sistema operativo multiusuario que permite que varios usuarios inicien sesión y usen la computadora. Para proteger la computadora (y la privacidad de otros usuarios), las capacidades de los usuarios están restringidas.

Hay un usuario especial en Linux conocido como superusuario, al que generalmente se le asigna el nombre de usuario root. El superusuario tiene acceso ilimitado a la computadora y puede hacer casi cualquier cosa. No es aconsejable trabajar con el usuario root por razones de seguridad.

Linux Users: https://www.raspberrypi.com/documentation/computers/using_linux.html#linux-users 

Root y sudo: https://www.raspberrypi.com/documentation/computers/using_linux.html#root-and-sudo 

Normalmente no iniciará sesión como root, pero puede usar el comando sudo para proporcionar acceso como superusuario. Si inicia sesión en su Raspberry Pi como usuario pi, entonces está iniciando sesión como un usuario normal. Puede ejecutar comandos como usuario raíz usando el comando sudo antes del programa que desea ejecutar.

Sudo: https://www.luisllamas.es/raspberry-pi-sudo/

El usuario pi predeterminado en el sistema operativo Raspberry Pi es miembro del grupo sudo. Esto brinda la capacidad de ejecutar comandos como root cuando están precedidos por sudo, y cambiar al usuario root con sudo su.

Usuarios y contraseñas: https://www.luisllamas.es/como-gestionar-usuarios-y-contrasenas-en-raspberry-pi/

Grupos de usuarios: https://www.luisllamas.es/como-gestionar-grupos-de-usuarios-en-raspberry-pi/

Práctica: crear un usuario con vuestro nombre y añadir al grupo sudo

  • useradd -c «Nombre Usuario» -g grupo -d /home/usuario -s /bin/bash nombreUsuario
  • Entrar como usuario creado: su – nombreUsuario
  • whoami
  • who
  • lastlog

Sistema de Ficheros y Directorios

Linux File System: https://www.raspberrypi.com/documentation/computers/using_linux.html#the-linux-file-system 

Estándar sistema de ficheros:

Home en Raspberry Pi: ​​https://www.raspberrypi.com/documentation/computers/using_linux.html#home 

Comandos para ficheros y directorios:

  • cat prueba.txt: Muestra el contenido del archivo prueba.txt.
  • cd /abc/xyz: Cambia el directorio actual al directorio /abc/xyz.
  • cp XXX: Copia el archivo o directorio XXX y lo pega en una ubicación especificada. Un ejemplo de esta orden sería: cp fichero.txt /home/pi/fichero.txt en el directorio actual y lo pega en el directorio /home/pi/. Si el archivo no está en el directorio actual debes poner la dirección donde se encuentra.
  • ls -l: Muestra una lista con los archivos presentes en el directorio actual además de otros datos interesantes como el tamaño del archivo, la fecha de modificación y los permisos.
  • mkdir carpeta_prueba: Crea una nueva carpeta carpeta_prueba dentro de la carpeta actual.
  • mv XXX: Mueve el archivo o carpeta llamado XXX a una localización específica. Un ejemplo de esta orden sería: mv fichero.txt /home/pi que movería fichero.txt presente en la actual carpeta a la dirección /home/pi. Si el fichero que queremos mover no se encuentra en la carpeta donde nos encontramos tenemos que añadir la dirección completa del mismo. Este comando también puede ser utilizado para renombrar archivos o carpetas, lo único que debemos hacer es moverlos en el mismo directorio pero con distinto nombre, por ejemplo: mv fichero.txt prueba.txt renombraría el fichero fichero.txt como prueba.txt.
  • rm prueba.txt: Borra el fichero prueba.txt
  • rmdir carpeta_prueba: Borra la carpeta carpeta_prueba. Esta acción solo puede efectuarse si la carpeta está vacía.
  • scp user@10.0.0.32:/some/path/file.txt: Copia un archivo a través de SSH. Se puede utilizar para descargar un archivo de un ordenador remoto a nuestra Raspberry Pi. Usuario@10.0.0.32 es el nombre de usuario y la dirección es la IP local del ordenador remoto y /ruta/path/archivo.txt es la ruta y el nombre de archivo del archivo en el ordenador remoto.
  • touch: Crea un fichero nuevo vacío en el directorio actual.

WinSCP: https://www.luisllamas.es/winscp-transfiere-archivos-entre-windows-y-rasperry-pi/

Más información: http://www.tldp.org/LDP/intro-linux/html/chap_03.html

Permisos de Ficheros 

En GNU/Linux, los permisos o derechos que los usuarios pueden tener sobre determinados archivos contenidos en él se establecen en tres niveles claramente diferenciados. Estos tres niveles son los siguientes:

  • Permisos del propietario.
  • Permisos del grupo.
  • Permisos del resto de usuarios (o también llamados “los otros”).

El comando chmod («change mode») permite modificar la máscara para que se puedan realizar más o menos operaciones sobre archivos o directorios, dicho de otra forma, con chmod puedes quitar o eliminar derechos a cada tipo de usuarios. Si no se especifica el tipo de usuario al que queremos quitar, poner o asignar privilegios, lo que sucederá al realizar la operación es afectar a todos los usuarios simultáneamente.

Dar permiso de ejecución al dueño: chmod u+x script.sh

Quitar permiso de ejecución a todos los usuarios: chmod -x script.sh

Representación octal de permisos. Uso: chmod 700 archivo/directorio

Para cambiar el usuario propietario de un fichero o carpeta usamos la orden chown (change owner). Uso: chown usuario:grupo archivo

Seguridad de los ficheros: http://www.tldp.org/LDP/intro-linux/html/sect_03_04.html

Más información:

Configuración Redes en Linux

  • ifconfig: Sirve para comprobar el estado de la conexión inalámbrica que estamos utilizando, por ejemplo para ver si wlan0 tiene asignada o no una dirección IP.
  • iwconfig: Para comprobar a qué red estamos conectados de forma inalámbrica.
  • iwlist wlan0 scan: Muestra una lista con todas las redes inalámbricas disponibles.
  • iwlist wlan0 scan | grep ESSID: Si a la orden anterior añadimos | grep junto con el nombre de un campo, el sistema nos mostrará por pantalla tan sólo el campo que necesitamos. Utilizando la orden de ejemplo tan sólo se listará el campo ESSID.
  • nmap: Escanea tu red y lista los dispositivos conectados, el número de puerto, el protocolo, el sistema operativo, las direcciones MAC…
  • ping: Prueba la conectividad entre dos dispositivos conectados a una  misma red. Por ejemplo, ping 10.0.0.32 enviará un paquete al dispositivo con IP 10.0.0.32 y esperará una respuesta. También funciona con las direcciones de sitios web lo que nos puede ayudar a saber si tenemos conexión a la red o no utilizando, por ejemplo, ping http://www.google.es
  • wget http://www.miweb.com/prueba.txt: Descarga el archivo prueba.txt desde la página web http://www.miweb.com y lo guarda en el directorio actual.

Networking: http://www.tldp.org/LDP/intro-linux/html/chap_10.html

Comandos Sistema

  • cat /proc/meminfo: Muestra información sobre nuestro sistema de memoria.
  • cat /proc/partitions: Muestra el tamaño y el número de particiones de la tarjeta SD o del disco duro.
  • cat /proc/version: Nos muestra la versión de la Raspberry Pi que estamos utilizando.
  • df -h: Muestra el espacio disponible en el disco.
  • df /: Muestra cuánto espacio libre en disco hay disponible.
  • dpkg –get-selections | grep XXX: Muestra todos los paquetes instalados relacionados con XXX.
  • dpkg –get-selections: Da información sobre todos los paquetes instalados.
  • free: Muestra la cantidad de memoria libre de la que dispone el sistema.
  • hostname -I: Muestra la dirección IP de nuestra Raspberry Pi.
  • top: Muestra los recursos del sistema
  • lsusb: Nos ofrece información sobre todos los dispositivos USB conectados a nuestra Raspberry Pi.
  • UP key: Al pulsar la tecla UP se introduce el último comando ingresado en el símbolo del sistema. Esta es una manera rápida de corregir los comandos que se hicieron en error.
  • vcgencmd measure_temp: Muestra la temperatura de la CPU.
  • vcgencmd get_mem arm && vcgencmd get_mem gpu: Muestra la memoria dividida entre la CPU y la GPU.

Más información sobre vcgencmd: https://www.raspberrypi.com/documentation/computers/os.html#vcgencmd 

Systemd. Para que un comando o programa se ejecute cuando se inicia Raspberry Pi, puede agregarlo como un servicio. Una vez hecho esto, puede iniciar/detener habilitar/deshabilitar desde el indicador de Linux. https://www.raspberrypi.com/documentation/computers/using_linux.html#the-systemd-daemon 

Todo sobre procesos: http://www.tldp.org/LDP/intro-linux/html/chap_04.html

Más información:

Kernel

Kernel Raspberry Pi OS: https://www.raspberrypi.com/documentation/computers/linux_kernel.html 

Kernel es un software que constituye la parte más importante del sistema operativo. Es el principal responsable de facilitar a los distintos programas acceso seguro al hardware de la computadora o en forma básica, es el encargado de gestionar recursos, a través de servicios de llamada al sistema.

Las principales funciones del Kernel son las siguientes:

  • Administra la memoria RAM, para que todos los programas y procesos en ejecución puedan funcionar.
  • Administra el tiempo del procesador, que se utiliza al ejecutar procesos.
  • Administra el acceso y uso de los diferentes periféricos conectados a la computadora.

Kernel Raspberry Pi: https://www.raspberrypi.com/documentation/computers/linux_kernel.html 

Bash Básico

Una Shell de Unix o también shell, es el término usado en informática para referirse a un intérprete de comandos, el cual consiste en la interfaz de usuario tradicional de los sistemas operativos basados en Unix y similares, como GNU/Linux.

GNU Bash o simplemente Bash (Bourne-again shell) es un lenguaje de comandos y shell de Unix escrito por Brian Fox para el Proyecto GNU. GNU Bash es el CLI implementado de forma mayoritaria en las distribuciones de Linux. Ejemplos de distribuciones que emplean Bash como CLI por defecto son Debian, openSUSE, Ubuntu, Fedora, Slackware, Mandriva.

Bash es el CLI incluido por defecto en Raspberry Pi.

Lanzado por primera vez en 1989, se ha utilizado ampliamente como el shell de inicio de sesión predeterminado para la mayoría de las distribuciones de Linux y MacOS Mojave de Apple y versiones anteriores.

Bash es un procesador de comandos que generalmente se ejecuta en una ventana de texto donde el usuario escribe comandos que causan acciones. Bash también puede leer y ejecutar comandos desde un archivo, llamado script de shell.

Autocompletado con Tabulación

Uno de los grandes «trucos» a la hora de emplear Bash y que nos ahorrará una enorme cantidad de tiempo es la función de autocompletado con la tecla tabulación.

Si en cualquier momento mientras escribimos un comando, un nombre de archivo, o algunos argumentos, pulsamos la tecla tabulación Bash sugiere la opción que empieza por lo que hemos escrito. En caso de haber más de una ocurrencia, se recorren cíclicamente las opciones disponibles.

Si existen muchas ocurrencias, al pulsar tabulación no aparecerá nada. Al pulsarla una segunda vez nos mostrará un listado con los comandos disponibles. Podemos añadir algunas letras más y pulsar tabulación para terminar el comando.

bashrc file: https://www.raspberrypi.com/documentation/computers/using_linux.html#the-bashrc-file 

Ejemplo de bashrc: http://raspberrypimaker.com/my-bashrc-file-and-what-it-does/

Historial de Comandos

Otra función que nos ahorrará mucho tiempo y que es una de las mejoras que introdujo Bash respecto a su antecesor SH, es el histórico de comandos.

En cualquier momento podemos recuperar un comando escrito con anterioridad pulsando la tecla «arriba» del teclado de flechas. Pulsar sucesivamente nos irá trayendo el comando anterior, hasta el inicio de la sesión del terminal. Si nos hemos pasado, podemos pulsar la tecla «abajo» para pasar al comando posterior.

Si ejecutamos el comando history aparecerán los últimos comandos ejecutados en terminal

Más Información:

Scripting:

Hello Word Bash: https://www.circuitbasics.com/how-to-write-and-run-a-shell-script-on-the-raspberry-pi/

Shell scripts utilizados: https://elpuig.xeill.net/Members/rborrell/articles/los-archivos-bashrc-bash_profile-etc-bashrc-etc-profile-los-archivos-bashrc-bash_profile-etc-bashrc-etc-profile-cual-utilizar

Shell script: https://www.raspberrypi.com/documentation/computers/using_linux.html#shell-scripts 

Práctica

Hello word de bash http://tldp.org/HOWTO/Bash-Prog-Intro-HOWTO-5.html 

Crear alias:

Redirecciones: http://www.tldp.org/LDP/intro-linux/html/sect_05_01.html

Filtros: http://www.tldp.org/LDP/intro-linux/html/sect_05_03.html

Enviroment y Bash: http://www.tldp.org/LDP/intro-linux/html/sect_07_02.html

Más información: https://www.luisllamas.es/bash-cli-raspberry-pi/

Programar Bash:

Automatizar Procesos

Cron es una herramienta para configurar tareas programadas en sistemas Unix. Se utiliza para programar comandos o scripts para que se ejecuten periódicamente ya intervalos fijos. Las tareas van desde la copia de seguridad de las carpetas de inicio del usuario todos los días a la medianoche hasta el registro de información de la CPU cada hora.

Automatizar Raspberry Pi con cron:

Log errores cron: https://raspberrypi.stackexchange.com/questions/3741/where-do-cron-error-message-go

OJO editar crontab con crontab -e y no editando /etc/crontab!!!!

Troubleshooting crontab: https://garyhall.org.uk/troubleshooting-cron-raspberry-pi.html

Hay varias formas de ejecutar un programa al inicio en la Raspberry Pi.

  • rc.local es un archivo administrado por el sistema ubicado en /etc/rc.local que se ejecuta después de que se hayan iniciado todos los servicios del sistema, es decir, después de la transición a un nivel de ejecución multiusuario. Es la forma más sencilla de hacer que los programas se ejecuten al inicio en sistemas Linux. Solo puede usar este método para programas sin elementos GUI (interfaz gráfica de usuario), ya que rc.local se ejecuta antes de que arranque el sistema de ventanas Raspberry Pi.
  • Usando cron, añadiendo el comando @reboot /ruta/a/script
  • Mediante un servicio de systemd

Monitorizar Linux

Monitorizar Linux:

Linux Cheat Sheets

Guia de uso de linux (buenas cheatsheet):

Cheat sheet completa: https://www.linuxtrainingacademy.com/linux-commands-cheat-sheet/

Cheat Sheets:

Instalar Webmin

Webmin es una herramienta de configuración de sistemas accesible vía web para sistemas Unix, como GNU/Linux y OpenSolaris. Con él se pueden configurar aspectos internos de muchos sistemas operativos, como usuarios, cuotas de espacio, servicios, archivos de configuración, apagado del equipo, etcétera, así como modificar y controlar muchas aplicaciones libres, como el servidor web Apache, PHP, MySQL, DNS, Samba, DHCP, entre otros.

Web: http://www.webmin.com/

Además de webmin disponemos de virtualmin que es más tipo plesk:

Instalación:

Es posible que haya que instalar algunas dependencias con:

  • sudo apt-get install perl libnet-ssleay-perl openssl libauthen-pam-perl libpam-runtime libio-pty-perl apt-show-versions python

Para comprobar que se ha instalado acceder desde un navegador a https://ip_address:10000

Más información:

Otra alternativa a webmin: https://cockpit-project.org/ 

Para Saber más Linux

Ampliar información de Linux:

Certificaciones Linux: https://www.genbeta.com/linux/que-certificaciones-lpic-como-podemos-obtenerlas-para-demostrar-nuestro-conocimiento-linux

Libros: